diff options
Diffstat (limited to 'MIBS/TNMS-NBI-MIB')
| -rw-r--r-- | MIBS/TNMS-NBI-MIB | 13522 |
1 files changed, 13522 insertions, 0 deletions
diff --git a/MIBS/TNMS-NBI-MIB b/MIBS/TNMS-NBI-MIB new file mode 100644 index 0000000..2989649 --- /dev/null +++ b/MIBS/TNMS-NBI-MIB @@ -0,0 +1,13522 @@ +-- +-- TNMS-NBI-MIB +-- Copyright (c) 2016 Coriant. All rights reserved. +-- The content of this document is subject to change without notice. +-- + +TNMS-NBI-MIB DEFINITIONS ::= BEGIN + +IMPORTS + MODULE-IDENTITY, OBJECT-TYPE, NOTIFICATION-TYPE, Integer32, Unsigned32, Counter32 + FROM SNMPv2-SMI + TEXTUAL-CONVENTION, TruthValue, AutonomousType, VariablePointer, TimeStamp, DateAndTime, RowStatus + FROM SNMPv2-TC + enterprises + FROM RFC1155-SMI; + +coriant OBJECT IDENTIFIER ::= { enterprises 42229 } + +svsProductMibs OBJECT IDENTIFIER ::= { coriant 6 } + +svsProxEnms MODULE-IDENTITY + LAST-UPDATED "201610280000Z" + ORGANIZATION "Coriant" + CONTACT-INFO + "Coriant Support" + DESCRIPTION + "TNMS SNMP NBI MIB for umbrella systems." + + REVISION "201610280000Z" + DESCRIPTION + "Support for retrieval of PM thresholds." + + REVISION "201610280000Z" + DESCRIPTION + "Enhancements to Performance Management data retrieval." + + REVISION "201603150000Z" + DESCRIPTION + "Support for Performance Management data retrieval." + + REVISION "201507240000Z" + DESCRIPTION + "Support for Ethernet Paths." + + REVISION "201504300000Z" + DESCRIPTION + "Support for heartbeat notifications. + Support for inform notifications. + New fields added to the NE/Module/Port/TP tables." + + REVISION "201410040000Z" + DESCRIPTION + "Added 'AdditionalInformation' field to alarm tables and traps." + + REVISION "201409290000Z" + DESCRIPTION + "General MIB revision." + + REVISION "201406230000Z" + DESCRIPTION + "First revision, based on TNMS-MIB. PEN is now coriant'(42229) + instead of 'sni'(231)." + ::= { svsProductMibs 22 } + + +-- -------------------------------------------------------------------------- +-- TEXTUAL-CONVENTION's +-- -------------------------------------------------------------------------- +DisplayString ::= TEXTUAL-CONVENTION + DISPLAY-HINT "255t" + STATUS current + DESCRIPTION "String of printable characters, meant to be displayed + to humans." + SYNTAX OCTET STRING (SIZE (0..255)) + + +Boolean ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION " true / false " + SYNTAX INTEGER + { + false(0), + true(1) + } + +TrapFilter ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Indicates if traps are sent for a type of notifications." + SYNTAX INTEGER + { + sendTrapsOn(1), + sendTrapsOff(2) + } + +EnmsTimeStamp ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Human-readable timestamp string. + Format: yyyy-MM-dd HH:mm:ss" + SYNTAX OCTET STRING (SIZE (0..255)) + +InfoString ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Parsable character string." + SYNTAX OCTET STRING (SIZE (0..255)) + +TPIndex ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "String with hexadecimal representation of a TP index." + SYNTAX OCTET STRING (SIZE (0..255)) + +UniqueId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Unsigned 32-bit unique identifier." + SYNTAX Unsigned32 + +NEId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of an NE." + SYNTAX UniqueId + +ModuleId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Module identifier within an NE." + SYNTAX UniqueId + +PortId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Port identifier within an NE." + SYNTAX UniqueId + +TPId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Higher or lower 32 bits of a TP identifier within a port." + SYNTAX UniqueId + +PortConnId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a port connection." + SYNTAX UniqueId + +SNCId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of an SNC." + SYNTAX UniqueId + +EthernetPathId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of an Ethernet Path." + SYNTAX UniqueId + +CCId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a CC." + SYNTAX UniqueId + +SubscriberId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a subscriber." + SYNTAX UniqueId + +ServiceId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a service." + SYNTAX UniqueId + +VpcId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a vpc. Not used." + SYNTAX UniqueId + +VccId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a vcc. Not used." + SYNTAX UniqueId + +Bandwidth ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Bandwidth representation." + SYNTAX OCTET STRING (SIZE (0..255)) + +PerceivedSeverity ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Enumeration of alarm severities." + SYNTAX INTEGER + { + cleared(0), + warning(1), + minor(2), + major(3), + critical(4), + indeterminate(5), + nonExistent(6), + nonAlarmed(7), + notAlarmed(8) + } + +AlarmClass ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Enumeration of alarm classes." + SYNTAX INTEGER + { + unknown(0), + communication(1), + quality(2), + processing(3), + equipment(4), + environment(5), + system (6), --new for TNMSV10.3 + threshold (7), + security (8) + } + +AlarmState ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Enumeration of alarm states." + SYNTAX INTEGER + { + noAlarm(1), + acknowledged(2), + unAcknowledged(3) + } + +OperationalState ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Operability of a resource: + - unknown: The operational state cannot be determined (e.g. NE + disconnected from DCN) + - enabled: The resource is available for use + - disabled: The resource is not operational + - partiallyEnabled: The resource is partially operational" + SYNTAX INTEGER + { + unknown(1), + enabled(2), + disabled(3), + partiallyEnabled(4) + } + +OperatingMode ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Ability of an NE to send notifications: + - operation: NE send all notifications + - maintenance: NE suppresses all notifications" + SYNTAX INTEGER + { + operation(1), + maintenance(2) + } + +AdministrativeState ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Administrative state of managed objects: + - unknown + - locked: Resource administratively prohibited from being used + - unlocked: Resource administratively permitted to be used" + SYNTAX INTEGER + { + unknown(0), + locked(1), + unlocked(2), + shuttingDown(3), -- currently not supported + starting(4) -- currently not supported + } + +ProvisioningState ::= TEXTUAL-CONVENTION + STATUS obsolete + DESCRIPTION + "Obsolete." + SYNTAX INTEGER + { + provisioned(1), + unprovisioned(2) + } + +UsageState ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "The usage state of a resource: + - idle: The resource is currently not in use + - active: Not used + - busy: The resource is in use (spare operating capacity + may be available, though)." + SYNTAX INTEGER + { + idle(1), + active(2), -- obsolete + busy(3) + } + +ProtectionState::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Protection state of a cross-connection: + - non(0): Not applicable (e.g. CC is unprotected) + - working(1): Traffic is selected from the working channel + - protecting(2): Traffic is selected from the protecting channel(s)" + SYNTAX INTEGER + { + non(0), -- information is not applicable (e.g. unprotected cross connection) + working(1), -- Traffic is currently selected from the working channel(s) + protecting(2) -- Traffic is currently selected from the protecting channel(s) + } + +EntityType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Enumeration of entity types." + SYNTAX INTEGER + { + other(0), + proxy(1), + module(2), + ne(3), + port(4), + tp(5), + portConn(6), + subNetworkConn(7), + subscriber(8), + service(9), + ems(10), --new for TNMSV10.3 + ethernetPath(11), + pmRequest(12), + opmRequest(13) + } + +ProbableCause ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Enumeration of alarm probable causes." + SYNTAX INTEGER + { + unknown (0), + acd (1), + acmT0 (2), + adapterError (3), + adapterError2 (4), + adapterError3 (5), + airCompressorFailure (6), + airConditioningFailure (7), + airDryerFailure (8), + ais (9), + aisA1 (10), + aisB1 (11), + aisSsf (12), + aisuk2 (13), + apf (14), + asf (15), + aw (16), + backplaneFailure (17), + battDischarge (18), + battery (19), + batteryDischarging (20), + batteryFailure (21), + batteryLow (22), + ber3 (23), + ber56 (24), + buffer (25), + cableProblem (26), + cableReference (27), + cardBreakdown (28), + cardDisabled (29), + cardFailure (30), + cardInUnconfiguredSlot (31), + cardProblem (32), + cfgFile (33), + chargeCurrent (34), + clk (35), + clock (36), + cni (37), + commercialPowerFailure (38), + commsLinkFail (39), + conf (40), + confEquip (41), + coolingFanFailure (42), + crcmismatch (43), + critical (44), + dbit (45), + dccBus (46), + deepDischarge (47), + dm (48), + dte (49), + ebsl (50), + enclosureDoorOpen (51), + engineFailure (52), + eni (53), + equipmentIdentifierDuplication (54), + esw (55), + ethernetFail (56), + excessiveBER (57), + explosiveGas (58), + fanUnit1 (59), + fanUnit2 (60), + fca (61), + fileError (62), + fire (63), + fireDetectorFailure (64), + flash1Cfg (65), + flash2Cfg (66), + flashCfg (67), + flashMemory (68), + flood (69), + foc (70), + fop (71), + frequencyDriftHighDegrade (72), + frequencyDriftLowDegrade (73), + frequencyHighDegrade (74), + frequencyHighFailure (75), + frequencyLowDegrade (76), + frequencyLowFailure (77), + fspfext (78), + fuseFailure (79), + generatorFailure (80), + genericEnv1 (81), + genericEnv2 (82), + genericEnv3 (83), + genericEnv4 (84), + genericEnv5 (85), + genericEnv6 (86), + genericEnv7 (87), + genericEnv8 (88), + genericEnv9 (89), + hardDisk (90), + highHumidity (91), + highTemperature (92), + highWind (93), + iceBuildUp (94), + icn (95), + indeterminate (96), + inp (97), + inputSignalLow (98), + intA (99), + intB (100), + internalComError (101), + internalCommunicationProblem (102), + internalCommunicationProblem2 (103), + internalCommunicationProblem3 (104), + internalControlBusX (105), + internalControlBusXY (106), + internalControlBusY (107), + intHWFail (108), + intrusionDetection (109), + intZ (110), + its (111), + kP (112), + krs (113), + ksd (114), + kss (115), + kzd (116), + lanaddr (117), + laserCurrent (118), + laserPowerHigh (119), + laserPowerLow (120), + laserTemperatureOutOfRange (121), + lcndcn (122), + lContFail (123), + lnkInt (124), + loa (125), + loc (126), + lof (127), + lom (128), + lomFarEnd (129), + loopNT1 (130), + lop (131), + los (132), + losa (133), + losA1 (134), + losA2 (135), + losb (136), + losB1 (137), + losB2 (138), + losS2M (139), + loss48V (140), + lossAC (141), + lossOfActivity (142), + lossOfCarrier (143), + lossOfD2an (144), + lossOfInternalTiming (145), + lossOfLockT0 (146), + lossOfLockT4 (147), + lossOfTiming (148), + lossOfTimingReference (149), + lossOfTimingT1 (150), + lossOfTimingT11 (151), + lossOfTimingT1121 (152), + lossOfTimingT12 (153), + lossOfTimingT1222 (154), + lossOfTimingT13 (155), + lossOfTimingT14 (156), + lossOfTimingT2 (157), + lossOfTimingT21 (158), + lossOfTimingT22 (159), + lossOfTimingT3 (160), + lossOfTimingT31 (161), + lossOfTimingT32 (162), + lossOfTimingT4 (163), + losUK2 (164), + lowCablePressure (165), + lowerCoolingFanFail (166), + lowFuel (167), + lowHumidity (168), + lowTemperature (169), + lowWater (170), + lsa (171), + lTan (172), + ltiT0 (173), + ltiT4 (174), + ltuFailure (175), + ltuMissing (176), + ltuTypeMismatch (177), + major (178), + mibDiscrepancy (179), + mibEmNotValid (180), + mibFlashFail (181), + mibFlashMissing (182), + mibNeNotValid (183), + minor (184), + powerProblem13 (185), + mod (186), + moduleCurrent (187), + multiframeCableProblem (188), + nas (189), + nbit (190), + ncm (191), + neBreakdown (192), + neFailure (193), + neProblem (194), + nk (195), + no2MbitMode (196), + noValidT3Signal (197), + npd (198), + npd2 (199), + npf (200), + nr (201), + oA (202), + oCH (203), + ohBus (204), + optBoosterTemperature (205), + opticPowerReceiveTooLow (206), + optPreampTemperature (207), + oSCLaserFail (208), + ows (209), + pathTraceMismatch (210), + pcbBusFail (211), + pilot (212), + pnvmod (213), + powerDriftHighDegrade (214), + powerDriftLowDegrade (215), + powerProblem1 (216), + powerProblem12 (217), + powerProblem2 (218), + powerProblem3 (219), + powerProblem34 (220), + powerProblem4 (221), + powerTooHighDegrade (222), + powerTooHighFailure (223), + powerTooLowDegrade (224), + powerTooLowFailure (225), + preemphasisFailure (226), + pri (227), + processProblem (228), + protectionBusX (229), + protectionBusXY (230), + protectionBusY (231), + psUfab (232), + psUfan (233), + psutp (234), + pumpLow (235), + pumpTemperature (236), + pwr (237), + pwrmod (238), + qA (239), + rdi (240), + receiverFailBooster (241), + rectifierFailure (242), + rectifierHighVoltageFailure (243), + rectifierLowVoltageFailure (244), + redundantPwr (245), + cardMissing (246), + cardMismatch (247), + ringFailure (248), + ringProblem (249), + rsa (250), + rxa (251), + rxb (252), + rxDegrade (253), + rxFail (254), + rxlineal (255), + sa4 (256), + ser (257), + serverSignalFail (258), + sfwrProblem (259), + sfwrProblemMajor (260), + signalDegraded (261), + signalLableMismatch (262), + signalToNoiseDegrade (263), + signalToNoiseDriftLowDegrade (264), + signalToNoiseFailure (265), + smoke (266), + snp (267), + sqm (268), + ssfEast (269), + ssfEastExtra (270), + ssfExtra (271), + ssfWest (272), + ssfWestExtra (273), + ssfWestWorking (274), + ssfWorking (275), + storageCapacity (276), + storageCapacityProblem (277), + sumAlarm (278), + swAbnormallyTerminated (279), + swEnvProblem (280), + switch (281), + swProgramError (282), + synchronizationSourceMismatch (283), + t0BusX (284), + t0BusY (285), + t0Quality (286), + telemetryInterface1 (287), + telemetryInterface10 (288), + telemetryInterface11 (289), + telemetryInterface12 (290), + telemetryInterface13 (291), + telemetryInterface14 (292), + telemetryInterface15 (293), + telemetryInterface16 (294), + telemetryInterface17 (295), + telemetryInterface18 (296), + telemetryInterface19 (297), + telemetryInterface2 (298), + telemetryInterface20 (299), + telemetryInterface21 (300), + telemetryInterface22 (301), + telemetryInterface23 (302), + telemetryInterface24 (303), + telemetryInterface25 (304), + telemetryInterface26 (305), + telemetryInterface27 (306), + telemetryInterface28 (307), + telemetryInterface29 (308), + telemetryInterface3 (309), + telemetryInterface30 (310), + telemetryInterface31 (311), + telemetryInterface32 (312), + telemetryInterface4 (313), + telemetryInterface5 (314), + telemetryInterface6 (315), + telemetryInterface7 (316), + telemetryInterface8 (317), + telemetryInterface9 (318), + temperatureHigh (319), + test (320), + thresholdBbe15 (321), + thresholdBbe15FarEnd (322), + thresholdBbe24 (323), + thresholdBbe24FarEnd (324), + thresholdCv15 (325), + thresholdCv24 (326), + thresholdEs15 (327), + thresholdEs15FarEnd (328), + thresholdEs24 (329), + thresholdEs24FarEnd (330), + thresholdOfs15 (331), + thresholdOfs24 (332), + thresholdPjePlus15 (333), + thresholdPjePlus24 (334), + thresholdPjeMinus15 (335), + thresholdPjeMinus24 (336), + thresholdSefs15 (337), + thresholdSefs24 (338), + thresholdSes15 (339), + thresholdSes15FarEnd (340), + thresholdSes24 (341), + thresholdSes24FarEnd (342), + thresholdUas15 (343), + thresholdUas15FarEnd (344), + thresholdUas24 (345), + thresholdUas24FarEnd (346), + thresholdUat (347), + thresholdUatFarEnd (348), + timeTickProblem (349), + timing (350), + timingProblem (351), + tma1 (352), + tma2 (353), + toxicGas (354), + transmitDegradeBooster1 (355), + transmitDegradeBooster2 (356), + transmitDegradePreamp1 (357), + transmitDegradePreamp2 (358), + transmitFailPreamp (359), + tsb (360), + txa (361), + txAis (362), + txb (363), + txDegrade (364), + txFail (365), + txlineal (366), + typeMismatch (367), + uat (368), + uLedFail (369), + undef (370), + unequipped (371), + unitUnknown (372), + upperCoolingFanFail (373), + ventilationSystemFailure (374), + versionMismatch (375), + voaProblem (376), + wAN (377), + warning (378), + wrongCardVersion (379), + wrongSW (380), + fanExtendedClimateClass (381), + fanNormalClimateClass (382), + voaProblem1 (383), + voaProblem2 (384), + voaProblem3 (385), + voaProblem4 (386), + remotePumpFailure (387), + transmitDegradePreamp3 (388), + transmitDegradePreamp4 (389), + noASEDetected (390), + noOscDuringStartup (391), + oalLaserDegrade (392), + powerProblem24 (393), + thresholdPsw (394), + oalLoopFail (395), + oalActivationInProgress (396), + laserTemperatureRingFail (397), + laserTemperatureClientFail (398), + apdTemperatureRingTooHigh (399), + apdTemperatureClientTooHigh (400), + protectionLogicProblem (401), + protectionLogicInconsistency (402), + pllSyncFailureRing (403), + pllSyncFailureClient (404), + internalLossOfSignal (405), + internalPowerTooHighFailure (406), + internalTransmitDegraded (407), + internalTransmitFailureSON (408), + opticalFilterTemperatureFailure (409), + opticalAmplifierGainFailure (410), + fportAttack (411), + opticalAmplifierTransmitDegrade (412), + ip2OsiConfig (413), + internalPowerTooLowFailure (414), + ber (415), + sectionTraceMismatch (416), + powerBusFail (417), + outgoingDefectIndication (418), + subAddressBoardFailure (419), + optReflection (420), + osaFail (421), + transmitDegradePump1 (422), + transmitFailPump1 (423), + transmitDegradePump2 (424), + transmitFailPump2 (425), + transmitDegradePump3 (426), + transmitFailPump3 (427), + transmitDegradePump4 (428), + transmitFailPump4 (429), + transmitDegradePump5 (430), + transmitFailPump5 (431), + receiverFailPreamp (432), + temperatureProblem (433), + tiltControlFailure (434), + transmitFailBooster (435), + switchProblemUpgradePath (436), + switchProblem2 (437), + switchProblem1 (438), + voaProblem5 (439), + voaProblem6 (440), + voaProblem7 (441), + voaProblem8 (442), + voaProblem9 (443), + voaProblem10 (444), + voaProblem11 (445), + voaProblem18 (446), + voaProblem14 (447), + voaProblem15 (448), + voaProblem16 (449), + voaProblem17 (450), + voaProblem20 (451), + voaProblem19 (452), + voaProblem12 (453), + voaProblem13 (454), + osaPowerFail (455), + transmitDegradeOSC1 (456), + transmitDegradeOSC2 (457), + cardTemperatureProblem (458), + lossOfTimingInput (459), + lossOfTandemConnection (460), + canBusFailure (461), + remote (462), + laserTemperatureProblem (463), + temperatureTooHigh (464), + bdi (465), + thresholdCbes15 (466), + thresholdCbes24 (467), + opticalAmplifierReceiveFailure (468), + np (469), + osi2IpConfig (470), + clockFail (471), + loop (472), + fanFailure (473), + busFailure (474), + interstageLossProblem (475), + thresholdCv15FarEnd (476), + thresholdCv24FarEnd (477), + thresholdSefs15FarEnd (478), + thresholdSefs24FarEnd (479), + portDisabled (480), + portNotPartitioned (481), + temperatureTooLow (482), + portNotLinked (483), + temperatureFail (484), + incomingAis (485), + intQc (486), + intSra (487), + intSraA (488), + intSraB (489), + alternateModulationSignal (490), + equipmentProblem (491), + intQcA (492), + intQcB (493), + intSmfA (494), + intSmfB (495), + noData (496), + laserBiasEoL (497), + laserTecEoL (498), + laserTempOoR (499), + lossOfOip (500), + lossOfOop (501), + oipTooHigh (502), + oopTooLow (503), + subModTempOoR (504), + lossOfLinkPulse (505), + clockFailTx (506), + laserDegrade (507), + elasticStoreOverflowRx (508), + elasticStoreOverflowTx (509), + fanFailure1 (510), + fanFailure2 (511), + fanFailure3 (512), + fanPowerFail1 (513), + fanPowerFail2 (514), + powerFail (515), + fuseFail1 (516), + fuseFail2 (517), + voltageTooHigh (518), + voltageTooLow (519), + pathTraceInconsistency (520), + iNNCDown (521), + interfaceDown (522), + emsSystemAlarm (523), + configurationError (524), + internalError (525), + securityViolation (526), + remoteOutgoingDefectIndication (527), + tcRdi (528), + tandemConnectionSignalDegraded (529), + tcPathTraceMismatch (530), + tcUnequipped (531), + unprotectedCardProblem (532), + btbCardMissing (533), + subrackCoolingProblem (534), + thresholdLowestCurrent (535), + thresholdLowCurrent (536), + thresholdHighCurrent (537), + thresholdHighestCurrent (538), + thresholdLowestOIP (539), + thresholdLowOIP (540), + thresholdHighestOIP (541), + thresholdHighOIP (542), + thresholdLowestOOP (543), + thresholdLowOOP (544), + thresholdHighestOOP (545), + thresholdHighOOP (546), + switchError (547), + thresholdLowestTemp (548), + thresholdLowTemp (549), + thresholdHighestTemp (550), + thresholdHighTemp (551), + thresholdLowestVolt (552), + thresholdLowVolt (553), + thresholdHighestVolt (554), + thresholdHighVolt (555), + linkDown (564), + dcnLinkDown (565), + lossOfSynch (568), + invalidLaserFrequency (590), + invalidLaserAttenuation (591), + dbFullBackupFailed (592), + dbBackupFailed (593), + vpAis (615), + batteryFailure2 (616), + criAlrExtUnmangedNE (617), + majAlrExtUnmangedNE (618), + minAlrExtUnmangedNE (619), + warAlrExtUnmangedNE (620), + genAlrExtUnmangedNE (621), + mIIConnectorProblem (622), + telemetryInterface1-4 (630), + telemetryInterface1-5 (631), + telemetryInterface1-6 (632), + telemetryInterface1-7 (633), + telemetryInterface1-8 (634), + telemetryInterface1-9 (635), + telemetryInterface1-3 (636), + telemetryInterface1-2 (637), + telemetryInterface1-1 (638), + telemetryInterface1-10 (639), + telemetryInterface1-11 (640), + telemetryInterface1-12 (641), + telemetryInterface1-13 (642), + telemetryInterface1-14 (643), + telemetryInterface1-15 (644), + telemetryInterface1-16 (646), + telemetryInterface2-4 (647), + telemetryInterface2-5 (648), + telemetryInterface2-6 (649), + telemetryInterface2-7 (650), + telemetryInterface2-8 (651), + telemetryInterface2-9 (652), + telemetryInterface2-3 (653), + telemetryInterface2-2 (654), + telemetryInterface2-1 (655), + telemetryInterface2-10 (656), + telemetryInterface2-11 (657), + telemetryInterface2-12 (658), + telemetryInterface2-13 (659), + telemetryInterface2-14 (660), + telemetryInterface2-15 (661), + telemetryInterface2-16 (662), + telemetryInterface3-4 (663), + telemetryInterface3-5 (664), + telemetryInterface3-6 (665), + telemetryInterface3-7 (666), + telemetryInterface3-8 (667), + telemetryInterface3-9 (668), + telemetryInterface3-3 (669), + telemetryInterface3-2 (670), + telemetryInterface3-1 (671), + telemetryInterface3-10 (672), + telemetryInterface3-11 (673), + telemetryInterface3-12 (674), + telemetryInterface3-13 (675), + telemetryInterface3-14 (676), + telemetryInterface3-15 (677), + telemetryInterface3-16 (678), + telemetryInterface4-4 (679), + telemetryInterface4-5 (680), + telemetryInterface4-6 (681), + telemetryInterface4-7 (682), + telemetryInterface4-8 (683), + telemetryInterface4-9 (684), + telemetryInterface4-3 (685), + telemetryInterface4-2 (686), + telemetryInterface4-1 (687), + telemetryInterface4-10 (688), + telemetryInterface4-11 (689), + telemetryInterface4-12 (690), + telemetryInterface4-13 (691), + telemetryInterface4-14 (692), + telemetryInterface4-15 (693), + telemetryInterface4-16 (694), + telemetryInterface5-4 (695), + telemetryInterface5-5 (696), + telemetryInterface5-6 (697), + telemetryInterface5-7 (698), + telemetryInterface5-8 (699), + telemetryInterface5-9 (700), + telemetryInterface5-3 (701), + telemetryInterface5-2 (702), + telemetryInterface5-1 (703), + telemetryInterface5-10 (704), + telemetryInterface5-11 (705), + telemetryInterface5-12 (706), + telemetryInterface5-13 (707), + telemetryInterface5-14 (708), + telemetryInterface5-15 (709), + telemetryInterface5-16 (710), + telemetryInterface6-4 (711), + telemetryInterface6-5 (712), + telemetryInterface6-6 (713), + telemetryInterface6-7 (714), + telemetryInterface6-8 (715), + telemetryInterface6-9 (716), + telemetryInterface6-3 (717), + telemetryInterface6-2 (718), + telemetryInterface6-1 (719), + telemetryInterface6-10 (720), + telemetryInterface6-11 (721), + telemetryInterface6-12 (722), + telemetryInterface6-13 (723), + telemetryInterface6-14 (724), + telemetryInterface6-15 (725), + telemetryInterface6-16 (726), + telemetryInterface7-4 (727), + telemetryInterface7-5 (728), + telemetryInterface7-6 (729), + telemetryInterface7-7 (730), + telemetryInterface7-8 (731), + telemetryInterface7-9 (732), + telemetryInterface7-3 (733), + telemetryInterface7-2 (734), + telemetryInterface7-1 (735), + telemetryInterface7-10 (736), + telemetryInterface7-11 (737), + telemetryInterface7-12 (738), + telemetryInterface7-13 (739), + telemetryInterface7-14 (740), + telemetryInterface7-15 (741), + telemetryInterface7-16 (742), + bandwithMismatch (743), + rpr3oClockSpainFail (744), + rpr9oClockSpainFail (745), + fanIsNecessary (746), + lossOfLock (747), + frequencyMismatch (748), + thresholdMaxBer15 (750), + thresholdMaxBer24 (751), + lofOtu (752), + externalFanFail (753), + multipleFanFail (754), + oscmBranchError (756), + ber6 (757), + bandwithNotAvailable (758), + equipmentAlarm (759), + losd (760), + underCurrent12 (761), + underCurrent1 (762), + underCurrent2 (763), + overload (764), + unsymmetricLoad (765), + defect (766), + remoteTerminalAlarm (767), + remotePowerFailAll (768), + laserAging (769), + remotePowerFail (770), + thresholdAttenuation (771), + thresholdSNR (772), + fanPowerFail (773), + voltageOoR (774), + ifModuleTempOoR (775), + partitioned (776), + halfPartialOperation (777), + fullPartialOperation (778), + unbalancedSignal (779), + internalUnbalancedSignal (780), + lossOfSignalT (781), + attAtROOR (782), + attAtTOOR (783), + linkRemoteFault (784), + linkNotAvailable (785), + neInRealignment (786), + anotherUserInWriteAccess (787), + lctUserInWriteAccess (788), + mibDownloadRunning (789), + alarmNotOk (790), + gbESFPMissing (791), + attenuationProblem (792), + airFilterExchangeRequired (793), + gtmModuleProblem (794), + muxDemuxProblem (795), + osaCalibrationDateExpired (796), + osaModuleProblem (797), + powerDriftLowFailure (798), + pqmModulemProblem (799), + temperatureProblem1 (800), + temperatureProblem2 (801), + temperatureProblem3 (802), + temperatureProblem4 (803), + subbandLoss (804), + switchProblem3 (805), + switchProblem4 (806), + targetValueNotReached (807), + temperaturRegulationRunning (808), + statusOfModuleToModuleCommunication (809), + inputReferenceAvailableStatus (810), + frequencyModeDegration (811), + frequencyControlParameterWithinSpecification (812), + outputFrequencyStatusWithinSpecification (813), + clockModuleUsableAsTheOutputReference (814), + statusOfTheNumericallyCntrlOscillPhaseLockLoop (815), + statusOfTheLocalOscillatorPhaseLockLoop (816), + statusOfTheRubidiumInternalPhaseLockLoop (817), + hwConfigurationFault (818), + statusPowerA (819), + statusPowerB (820), + statusOfSpiHw (821), + clockPllNotLocked (822), + inputPllNotLocked (823), + bipolarViolationSignalFault (824), + crcErrorFaultStatus (825), + mtieLimit1Exceeded (826), + mtieLimit2Exceeded (827), + receivedPqlBelowProvisionPqlStatus (828), + noSsmStatus (829), + moduleBootProblem (830), + phaseMeasurementHwFault (831), + frequencyMeasurementRangeExceeded (832), + indicationOfOutputControllerMastership (833), + clockPllStatusFault (834), + phaseHwFault (835), + manufacturingItemNumberFault (836), + positionUnknownFault (837), + engineSystemFault (838), + gpsEngineHwFault (839), + antennaConditionFault (840), + antennaConnectionStatus (841), + gpsEngineTrackingStatus (842), + systemSwFault (843), + configurationStatus (844), + clockBelowMinimumClockLevel (845), + lossOfClockSourceC (846), + mismatchedModules (848), + lossOfClockSourceA (849), + lossOfClockSourceB (850), + clockNotSelectedForOutput (851), + redundantModuleStatus (852), + vcxoStatus (853), + outputPllStatus (854), + lossOfClockSourceD (855), + outputPortFault (856), + internalPortFault (857), + externalPortFault (858), + powerA (859), + powerB (860), + payloadMismatch (861), + lockedDefect (862), + lofLom (863), + lossOfFrameDelineation (880), + lsuMissing (881), + t0 (882), + t0X (883), + t0Y (884), + swIncomplete (885), + portAbsent (886), + portMismatch (887), + utif (888), + utifX (889), + utifY (890), + istm (891), + istmX (892), + istmY (893), + lossOfTimingT15 (894), + lossOfTimingT16 (895), + lossOfTimingT17 (896), + lossOfTimingT18 (897), + lossOfMultiframeT31 (898), + lossOfMultiframeT32 (899), + lossOfFrameT31 (900), + lossOfFrameT32 (901), + primaryPower (902), + redundantPower (903), + linkLoss (904), + feLinkDown (905), + provisionError (906), + lsu1Missing (907), + lsu2Missing (908), + lowerCoolingFanMissing (909), + upperCoolingFanMissing (910), + lossOfActivityTx (911), + lossOfActivityRx (912), + optPort1 (913), + optPort2 (914), + optPort3 (915), + optPort4 (916), + dccLinkDown (917), + rxSignalOverload (918), + plugInMissing (919), + plugInMismatch (920), + plugInNotApproved (921), + gfpLOF (922), + gfpPLM (923), + gfpLOClientSig (924), + gfpLOCharSync (925), + gfptClientSignalFailure (926), + lossOfAddSignal (927), + mwbModuleProblem (928), + mwbCommunicationProblem (929), + connectionLossToNE (930), + subSystemMissing (931), + subSystemFailure (932), + fanUnit (933), + dcnOverload (934), + eowUnavailable (935), + connectionIdMismatch (936), + iLinkFailure (937), + laserCurrentTooHigh (938), + dataRateMismatch (939), + laserCurrentTooLow (940), + oipTooLow (941), + oopTooHigh (942), + attAtRTooHigh (943), + attAtRTooLow (944), + attAtTTooLow (945), + attAtTTooHigh (946), + intrusionAtR (947), + intrusionAtT (948), + attRxMonLow (949), + attRxMonHigh (950), + attTxMonLow (951), + attTxMonHigh (952), + unsuccessfulLoginsExceeded (953), + passwordExpired (954), + powerDriftFailure (955), + measurementFailure (956), + couplerDropLoss (957), + gainProblem (958), + spanLossLow (959), + spanLossHigh (960), + channelUpgradeOrderViolation1 (961), + channelUpgradeOrderViolation2 (962), + channelUpgradeOrderViolation3 (963), + channelUpgradeOrderViolation4 (964), + lossOfSignalPQM (965), + powerDifferentialAlarm (966), + lossOfSyncCommPartner (967), + testloop4b (968), + pathProtectionNotAvailable (969), + continuous0 (970), + nip (971), + lpt (972), + switchProblem (973), + oliConnectionCableFail (974), + iLANFailed (975), + activeLoop (976), + connectionLossToGne (977), + invalidGatewayAddress (978), + noLightDetectedC1 (979), + noLightDetectedC2 (980), + passwordWillExpireSoon (981), + equipmentAlarmNoFeedback (982), + noLightDetectedC3 (983), + noLightDetectedC4 (984), + channelCountMismatchC1 (985), + channelCountMismatchC2 (986), + channelCountMismatchC3 (987), + channelCountMismatchC4 (988), + linkControlSequenceFail1 (989), + linkControlSequenceFail2 (990), + linkControlSequenceFail3 (991), + linkControlSequenceFail4 (992), + noTimingMaster (993), + twoTimingMasters (994), + oscVersionMismatch (995), + eOpenConnectionIndication (996), + openConnectionIndication (997), + lossOfTCM (998), + syncFail (999), + requestInProgress (1000), + automaticPowerReductionMode (1002), + channelPowerMismatch1 (1005), + channelPowerMismatch2 (1006), + channelPowerMismatch3 (1007), + channelPowerMismatch4 (1008), + secondSyncMasterDetected (1015), + trapComLost (1016), + requestComLost (1017), + notInSynch (1018), + sfcHwFault (1019), + powerSourceA-Fault (1020), + powerSourceB-Fault (1021), + powerSupplyA-DcFault (1022), + powerSupplyB-DcFault (1023), + powerSupplyA-AcFault (1024), + powerSupplyB-AcFault (1025), + powerSupplyA-Missing (1026), + powerSupplyB-Missing (1027), + discrete1Fault (1028), + discrete2Fault (1029), + unidirectTestFailure (1030), + testFailure (1031), + unreachedRmNode (1032), + multipleRmNode (1033), + ftmMissing (1034), + sfpMissing (1035), + macsLimitReached (1036), + efmOamFault (1037), + swUpgradeHault (1038), + swUpgradeFault (1039), + psuFault (1040), + netSfpAMismatch (1041), + netOptBFault (1042), + netOptAFault (1043), + netBMisConfig (1044), + netAMisConfig (1045), + accOptFault (1046), + accSfpMismatch (1047), + accMisConfig (1048), + tIFActivatedAlarm (1049), + thresholdCvAsap (1050), + thresholdEsAsap (1051), + thresholdSesAsap (1052), + thresholdSefsAsap (1053), + thresholdCbesAsap (1054), + thresholdUasAsap (1055), + thresholdEsFarEndAsap (1056), + thresholdSesFarEndAsap (1057), + thresholdCvOutAsap (1058), + thresholdCvFarEndAsap (1059), + thresholdUasFarEndAsap (1060), + thresholdEsOutAsap (1061), + thresholdSesOutAsap (1062), + thresholdUasOutAsap (1063), + thresholdSefsOutAsap (1064), + thresholdMaxBerAsap (1065), + thresholdBbeAsap (1066), + thresholdBbeFarEndAsap (1067), + thresholdBbeOutAsap (1068), + transmitDegradeTSCh1 (1069), + transmitDegradeTSCh2 (1070), + transmitDegradeTSCh3 (1071), + transmitDegradeTSCh4 (1072), + temperatureProblemTSCh1 (1073), + temperatureProblemTSCh2 (1074), + temperatureProblemTSCh3 (1075), + temperatureProblemTSCh4 (1076), + transmitFailTSCh1 (1077), + transmitFailTSCh2 (1078), + transmitFailTSCh3 (1079), + transmitFailTSCh4 (1080), + shelfAddressChanged (1081), + downgradeChannelsInProgress (1082), + allChannelsDownloaded (1083), + inputLossOfLight1 (1093), + inputLossOfLight2 (1094), + inputLossOfLight3 (1095), + temperatureProblemVOA (1096), + dspProblem (1097), + controlOrCablingProblem (1098), + multiplexStructIndicationMism (1099), + telemetryInterface180-1 (1100), + telemetryInterface180-10 (1101), + telemetryInterface180-11 (1102), + telemetryInterface180-12 (1103), + telemetryInterface180-13 (1104), + telemetryInterface180-14 (1105), + telemetryInterface180-15 (1106), + telemetryInterface180-16 (1107), + telemetryInterface180-2 (1108), + telemetryInterface180-3 (1109), + telemetryInterface180-4 (1110), + telemetryInterface180-5 (1111), + telemetryInterface180-6 (1112), + telemetryInterface180-7 (1113), + telemetryInterface180-8 (1114), + telemetryInterface180-9 (1115), + telemetryInterface181-1 (1116), + telemetryInterface181-10 (1117), + telemetryInterface181-11 (1118), + telemetryInterface181-12 (1119), + telemetryInterface181-13 (1120), + telemetryInterface181-14 (1121), + telemetryInterface181-15 (1122), + telemetryInterface181-16 (1123), + telemetryInterface181-2 (1124), + telemetryInterface181-3 (1125), + telemetryInterface181-4 (1126), + telemetryInterface181-5 (1127), + telemetryInterface181-6 (1128), + telemetryInterface181-7 (1129), + telemetryInterface181-8 (1130), + telemetryInterface181-9 (1131), + telemetryInterface182-1 (1132), + telemetryInterface182-10 (1133), + telemetryInterface182-11 (1134), + telemetryInterface182-12 (1135), + telemetryInterface182-13 (1136), + telemetryInterface182-14 (1137), + telemetryInterface182-15 (1138), + telemetryInterface182-16 (1139), + telemetryInterface182-2 (1140), + telemetryInterface182-3 (1141), + telemetryInterface182-4 (1142), + telemetryInterface182-5 (1143), + telemetryInterface182-6 (1144), + telemetryInterface182-7 (1145), + telemetryInterface182-8 (1146), + telemetryInterface182-9 (1147), + telemetryInterface183-1 (1148), + telemetryInterface183-10 (1149), + telemetryInterface183-11 (1150), + telemetryInterface183-12 (1151), + telemetryInterface183-13 (1152), + telemetryInterface183-14 (1153), + telemetryInterface183-15 (1154), + telemetryInterface183-16 (1155), + telemetryInterface183-2 (1156), + telemetryInterface183-3 (1157), + telemetryInterface183-4 (1158), + telemetryInterface183-5 (1159), + telemetryInterface183-6 (1160), + telemetryInterface183-7 (1161), + telemetryInterface183-8 (1162), + telemetryInterface183-9 (1163), + telemetryInterface184-1 (1164), + telemetryInterface184-10 (1165), + telemetryInterface184-11 (1166), + telemetryInterface184-12 (1167), + telemetryInterface184-13 (1168), + telemetryInterface184-14 (1169), + telemetryInterface184-15 (1170), + telemetryInterface184-16 (1171), + telemetryInterface184-2 (1172), + telemetryInterface184-3 (1173), + telemetryInterface184-4 (1174), + telemetryInterface184-5 (1175), + telemetryInterface184-6 (1176), + telemetryInterface184-7 (1177), + telemetryInterface184-8 (1178), + telemetryInterface184-9 (1179), + telemetryInterface185-1 (1180), + telemetryInterface185-10 (1181), + telemetryInterface185-11 (1182), + telemetryInterface185-12 (1183), + telemetryInterface185-13 (1184), + telemetryInterface185-14 (1185), + telemetryInterface185-15 (1186), + telemetryInterface185-16 (1187), + telemetryInterface185-2 (1188), + telemetryInterface185-3 (1189), + telemetryInterface185-4 (1190), + telemetryInterface185-5 (1191), + telemetryInterface185-6 (1192), + telemetryInterface185-7 (1193), + telemetryInterface185-8 (1194), + telemetryInterface185-9 (1195), + telemetryInterface186-1 (1196), + telemetryInterface186-10 (1197), + telemetryInterface186-11 (1198), + telemetryInterface186-12 (1199), + telemetryInterface186-13 (1200), + telemetryInterface186-14 (1201), + telemetryInterface186-15 (1202), + telemetryInterface186-16 (1203), + telemetryInterface186-2 (1204), + telemetryInterface186-3 (1205), + telemetryInterface186-4 (1206), + telemetryInterface186-5 (1207), + telemetryInterface186-6 (1208), + telemetryInterface186-7 (1209), + telemetryInterface186-8 (1210), + telemetryInterface186-9 (1211), + telemetryInterface187-1 (1212), + telemetryInterface187-10 (1213), + telemetryInterface187-11 (1214), + telemetryInterface187-12 (1215), + telemetryInterface187-13 (1216), + telemetryInterface187-14 (1217), + telemetryInterface187-15 (1218), + telemetryInterface187-16 (1219), + telemetryInterface187-2 (1220), + telemetryInterface187-3 (1221), + telemetryInterface187-4 (1222), + telemetryInterface187-5 (1223), + telemetryInterface187-6 (1224), + telemetryInterface187-7 (1225), + telemetryInterface187-8 (1226), + telemetryInterface187-9 (1227), + telemetryInterface200-1 (1228), + telemetryInterface200-10 (1229), + telemetryInterface200-11 (1230), + telemetryInterface200-12 (1231), + telemetryInterface200-13 (1232), + telemetryInterface200-14 (1233), + telemetryInterface200-15 (1234), + telemetryInterface200-16 (1235), + telemetryInterface200-2 (1236), + telemetryInterface200-3 (1237), + telemetryInterface200-4 (1238), + telemetryInterface200-5 (1239), + telemetryInterface200-6 (1240), + telemetryInterface200-7 (1241), + telemetryInterface200-8 (1242), + telemetryInterface200-9 (1243), + telemetryInterface201-1 (1244), + telemetryInterface201-10 (1245), + telemetryInterface201-11 (1246), + telemetryInterface201-12 (1247), + telemetryInterface201-13 (1248), + telemetryInterface201-14 (1249), + telemetryInterface201-15 (1250), + telemetryInterface201-16 (1251), + telemetryInterface201-2 (1252), + telemetryInterface201-3 (1253), + telemetryInterface201-4 (1254), + telemetryInterface201-5 (1255), + telemetryInterface201-6 (1256), + telemetryInterface201-7 (1257), + telemetryInterface201-8 (1258), + telemetryInterface201-9 (1259), + telemetryInterface202-1 (1260), + telemetryInterface202-10 (1261), + telemetryInterface202-11 (1262), + telemetryInterface202-12 (1263), + telemetryInterface202-13 (1264), + telemetryInterface202-14 (1265), + telemetryInterface202-15 (1266), + telemetryInterface202-16 (1267), + telemetryInterface202-2 (1268), + telemetryInterface202-3 (1269), + telemetryInterface202-4 (1270), + telemetryInterface202-5 (1271), + telemetryInterface202-6 (1272), + telemetryInterface202-7 (1273), + telemetryInterface202-8 (1274), + telemetryInterface202-9 (1275), + telemetryInterface203-1 (1276), + telemetryInterface203-10 (1277), + telemetryInterface203-11 (1278), + telemetryInterface203-12 (1279), + telemetryInterface203-13 (1280), + telemetryInterface203-14 (1281), + telemetryInterface203-15 (1282), + telemetryInterface203-16 (1283), + telemetryInterface203-2 (1284), + telemetryInterface203-3 (1285), + telemetryInterface203-4 (1286), + telemetryInterface203-5 (1287), + telemetryInterface203-6 (1288), + telemetryInterface203-7 (1289), + telemetryInterface203-8 (1290), + telemetryInterface203-9 (1291), + telemetryInterface204-1 (1292), + telemetryInterface204-10 (1293), + telemetryInterface204-11 (1294), + telemetryInterface204-12 (1295), + telemetryInterface204-13 (1296), + telemetryInterface204-14 (1297), + telemetryInterface204-15 (1298), + telemetryInterface204-16 (1299), + telemetryInterface204-2 (1300), + telemetryInterface204-3 (1301), + telemetryInterface204-4 (1302), + telemetryInterface204-5 (1303), + telemetryInterface204-6 (1304), + telemetryInterface204-7 (1305), + telemetryInterface204-8 (1306), + telemetryInterface204-9 (1307), + telemetryInterface205-1 (1308), + telemetryInterface205-10 (1309), + telemetryInterface205-11 (1310), + telemetryInterface205-12 (1311), + telemetryInterface205-13 (1312), + telemetryInterface205-14 (1313), + telemetryInterface205-15 (1314), + telemetryInterface205-16 (1315), + telemetryInterface205-2 (1316), + telemetryInterface205-3 (1317), + telemetryInterface205-4 (1318), + telemetryInterface205-5 (1319), + telemetryInterface205-6 (1320), + telemetryInterface205-7 (1321), + telemetryInterface205-8 (1322), + telemetryInterface205-9 (1323), + telemetryInterface206-1 (1324), + telemetryInterface206-10 (1325), + telemetryInterface206-11 (1326), + telemetryInterface206-12 (1327), + telemetryInterface206-13 (1328), + telemetryInterface206-14 (1329), + telemetryInterface206-15 (1330), + telemetryInterface206-16 (1331), + telemetryInterface206-2 (1332), + telemetryInterface206-3 (1333), + telemetryInterface206-4 (1334), + telemetryInterface206-5 (1335), + telemetryInterface206-6 (1336), + telemetryInterface206-7 (1337), + telemetryInterface206-8 (1338), + telemetryInterface206-9 (1339), + telemetryInterface207-1 (1340), + telemetryInterface207-10 (1341), + telemetryInterface207-11 (1342), + telemetryInterface207-12 (1343), + telemetryInterface207-13 (1344), + telemetryInterface207-14 (1345), + telemetryInterface207-15 (1346), + telemetryInterface207-16 (1347), + telemetryInterface207-2 (1348), + telemetryInterface207-3 (1349), + telemetryInterface207-4 (1350), + telemetryInterface207-5 (1351), + telemetryInterface207-6 (1352), + telemetryInterface207-7 (1353), + telemetryInterface207-8 (1354), + telemetryInterface207-9 (1355), + telemetryInterface210-1 (1356), + telemetryInterface210-10 (1357), + telemetryInterface210-11 (1358), + telemetryInterface210-12 (1359), + telemetryInterface210-13 (1360), + telemetryInterface210-14 (1361), + telemetryInterface210-15 (1362), + telemetryInterface210-16 (1363), + telemetryInterface210-2 (1364), + telemetryInterface210-3 (1365), + telemetryInterface210-4 (1366), + telemetryInterface210-5 (1367), + telemetryInterface210-6 (1368), + telemetryInterface210-7 (1369), + telemetryInterface210-8 (1370), + telemetryInterface210-9 (1371), + telemetryInterface211-1 (1372), + telemetryInterface211-10 (1373), + telemetryInterface211-11 (1374), + telemetryInterface211-12 (1375), + telemetryInterface211-13 (1376), + telemetryInterface211-14 (1377), + telemetryInterface211-15 (1378), + telemetryInterface211-16 (1379), + telemetryInterface211-2 (1380), + telemetryInterface211-3 (1381), + telemetryInterface211-4 (1382), + telemetryInterface211-5 (1383), + telemetryInterface211-6 (1384), + telemetryInterface211-7 (1385), + telemetryInterface211-8 (1386), + telemetryInterface211-9 (1387), + telemetryInterface212-1 (1388), + telemetryInterface212-10 (1389), + telemetryInterface212-11 (1390), + telemetryInterface212-12 (1391), + telemetryInterface212-13 (1392), + telemetryInterface212-14 (1393), + telemetryInterface212-15 (1394), + telemetryInterface212-16 (1395), + telemetryInterface212-2 (1396), + telemetryInterface212-3 (1397), + telemetryInterface212-4 (1398), + telemetryInterface212-5 (1399), + telemetryInterface212-6 (1400), + telemetryInterface212-7 (1401), + telemetryInterface212-8 (1402), + telemetryInterface212-9 (1403), + telemetryInterface213-1 (1404), + telemetryInterface213-10 (1405), + telemetryInterface213-11 (1406), + telemetryInterface213-12 (1407), + telemetryInterface213-13 (1408), + telemetryInterface213-14 (1409), + telemetryInterface213-15 (1410), + telemetryInterface213-16 (1411), + telemetryInterface213-2 (1412), + telemetryInterface213-3 (1413), + telemetryInterface213-4 (1414), + telemetryInterface213-5 (1415), + telemetryInterface213-6 (1416), + telemetryInterface213-7 (1417), + telemetryInterface213-8 (1418), + telemetryInterface213-9 (1419), + telemetryInterface214-1 (1420), + telemetryInterface214-10 (1421), + telemetryInterface214-11 (1422), + telemetryInterface214-12 (1423), + telemetryInterface214-13 (1424), + telemetryInterface214-14 (1425), + telemetryInterface214-15 (1426), + telemetryInterface214-16 (1427), + telemetryInterface214-2 (1428), + telemetryInterface214-3 (1429), + telemetryInterface214-4 (1430), + telemetryInterface214-5 (1431), + telemetryInterface214-6 (1432), + telemetryInterface214-7 (1433), + telemetryInterface214-8 (1434), + telemetryInterface214-9 (1435), + telemetryInterface215-1 (1436), + telemetryInterface215-10 (1437), + telemetryInterface215-11 (1438), + telemetryInterface215-12 (1439), + telemetryInterface215-13 (1440), + telemetryInterface215-14 (1441), + telemetryInterface215-15 (1442), + telemetryInterface215-16 (1443), + telemetryInterface215-2 (1444), + telemetryInterface215-3 (1445), + telemetryInterface215-4 (1446), + telemetryInterface215-5 (1447), + telemetryInterface215-6 (1448), + telemetryInterface215-7 (1449), + telemetryInterface215-8 (1450), + telemetryInterface215-9 (1451), + telemetryInterface216-1 (1452), + telemetryInterface216-10 (1453), + telemetryInterface216-11 (1454), + telemetryInterface216-12 (1455), + telemetryInterface216-13 (1456), + telemetryInterface216-14 (1457), + telemetryInterface216-15 (1458), + telemetryInterface216-16 (1459), + telemetryInterface216-2 (1460), + telemetryInterface216-3 (1461), + telemetryInterface216-4 (1462), + telemetryInterface216-5 (1463), + telemetryInterface216-6 (1464), + telemetryInterface216-7 (1465), + telemetryInterface216-8 (1466), + telemetryInterface216-9 (1467), + telemetryInterface217-1 (1468), + telemetryInterface217-10 (1469), + telemetryInterface217-11 (1470), + telemetryInterface217-12 (1471), + telemetryInterface217-13 (1472), + telemetryInterface217-14 (1473), + telemetryInterface217-15 (1474), + telemetryInterface217-16 (1475), + telemetryInterface217-2 (1476), + telemetryInterface217-3 (1477), + telemetryInterface217-4 (1478), + telemetryInterface217-5 (1479), + telemetryInterface217-6 (1480), + telemetryInterface217-7 (1481), + telemetryInterface217-8 (1482), + telemetryInterface217-9 (1483), + telemetryInterface300-1 (1484), + telemetryInterface300-10 (1485), + telemetryInterface300-11 (1486), + telemetryInterface300-12 (1487), + telemetryInterface300-13 (1488), + telemetryInterface300-14 (1489), + telemetryInterface300-15 (1490), + telemetryInterface300-16 (1491), + telemetryInterface300-2 (1492), + telemetryInterface300-3 (1493), + telemetryInterface300-4 (1494), + telemetryInterface300-5 (1495), + telemetryInterface300-6 (1496), + telemetryInterface300-7 (1497), + telemetryInterface300-8 (1498), + telemetryInterface300-9 (1499), + telemetryInterface301-1 (1500), + telemetryInterface301-10 (1501), + telemetryInterface301-11 (1502), + telemetryInterface301-12 (1503), + telemetryInterface301-13 (1504), + telemetryInterface301-14 (1505), + telemetryInterface301-15 (1506), + telemetryInterface301-16 (1507), + telemetryInterface301-2 (1508), + telemetryInterface301-3 (1509), + telemetryInterface301-4 (1510), + telemetryInterface301-5 (1511), + telemetryInterface301-6 (1512), + telemetryInterface301-7 (1513), + telemetryInterface301-8 (1514), + telemetryInterface301-9 (1515), + telemetryInterface302-1 (1516), + telemetryInterface302-10 (1517), + telemetryInterface302-11 (1518), + telemetryInterface302-12 (1519), + telemetryInterface302-13 (1520), + telemetryInterface302-14 (1521), + telemetryInterface302-15 (1522), + telemetryInterface302-16 (1523), + telemetryInterface302-2 (1524), + telemetryInterface302-3 (1525), + telemetryInterface302-4 (1526), + telemetryInterface302-5 (1527), + telemetryInterface302-6 (1528), + telemetryInterface302-7 (1529), + telemetryInterface302-8 (1530), + telemetryInterface302-9 (1531), + telemetryInterface303-1 (1532), + telemetryInterface303-10 (1533), + telemetryInterface303-11 (1534), + telemetryInterface303-12 (1535), + telemetryInterface303-13 (1536), + telemetryInterface303-14 (1537), + telemetryInterface303-15 (1538), + telemetryInterface303-16 (1539), + telemetryInterface303-2 (1540), + telemetryInterface303-3 (1541), + telemetryInterface303-4 (1542), + telemetryInterface303-5 (1543), + telemetryInterface303-6 (1544), + telemetryInterface303-7 (1545), + telemetryInterface303-8 (1546), + telemetryInterface303-9 (1547), + telemetryInterface304-1 (1548), + telemetryInterface304-10 (1549), + telemetryInterface304-11 (1550), + telemetryInterface304-12 (1551), + telemetryInterface304-13 (1552), + telemetryInterface304-14 (1553), + telemetryInterface304-15 (1554), + telemetryInterface304-16 (1555), + telemetryInterface304-2 (1556), + telemetryInterface304-3 (1557), + telemetryInterface304-4 (1558), + telemetryInterface304-5 (1559), + telemetryInterface304-6 (1560), + telemetryInterface304-7 (1561), + telemetryInterface304-8 (1562), + telemetryInterface304-9 (1563), + telemetryInterface305-1 (1564), + telemetryInterface305-10 (1565), + telemetryInterface305-11 (1566), + telemetryInterface305-12 (1567), + telemetryInterface305-13 (1568), + telemetryInterface305-14 (1569), + telemetryInterface305-15 (1570), + telemetryInterface305-16 (1571), + telemetryInterface305-2 (1572), + telemetryInterface305-3 (1573), + telemetryInterface305-4 (1574), + telemetryInterface305-5 (1575), + telemetryInterface305-6 (1576), + telemetryInterface305-7 (1577), + telemetryInterface305-8 (1578), + telemetryInterface305-9 (1579), + telemetryInterface306-1 (1580), + telemetryInterface306-10 (1581), + telemetryInterface306-11 (1582), + telemetryInterface306-12 (1583), + telemetryInterface306-13 (1584), + telemetryInterface306-14 (1585), + telemetryInterface306-15 (1586), + telemetryInterface306-16 (1587), + telemetryInterface306-2 (1588), + telemetryInterface306-3 (1589), + telemetryInterface306-4 (1590), + telemetryInterface306-5 (1591), + telemetryInterface306-6 (1592), + telemetryInterface306-7 (1593), + telemetryInterface306-8 (1594), + telemetryInterface306-9 (1595), + telemetryInterface307-1 (1596), + telemetryInterface307-10 (1597), + telemetryInterface307-11 (1598), + telemetryInterface307-12 (1599), + telemetryInterface307-13 (1600), + telemetryInterface307-14 (1601), + telemetryInterface307-15 (1602), + telemetryInterface307-16 (1603), + telemetryInterface307-2 (1604), + telemetryInterface307-3 (1605), + telemetryInterface307-4 (1606), + telemetryInterface307-5 (1607), + telemetryInterface307-6 (1608), + telemetryInterface307-7 (1609), + telemetryInterface307-8 (1610), + telemetryInterface307-9 (1611), + telemetryInterface310-1 (1612), + telemetryInterface310-10 (1613), + telemetryInterface310-11 (1614), + telemetryInterface310-12 (1615), + telemetryInterface310-13 (1616), + telemetryInterface310-14 (1617), + telemetryInterface310-15 (1618), + telemetryInterface310-16 (1619), + telemetryInterface310-2 (1620), + telemetryInterface310-3 (1621), + telemetryInterface310-4 (1622), + telemetryInterface310-5 (1623), + telemetryInterface310-6 (1624), + telemetryInterface310-7 (1625), + telemetryInterface310-8 (1626), + telemetryInterface310-9 (1627), + telemetryInterface311-1 (1628), + telemetryInterface311-10 (1629), + telemetryInterface311-11 (1630), + telemetryInterface311-12 (1631), + telemetryInterface311-13 (1632), + telemetryInterface311-14 (1633), + telemetryInterface311-15 (1634), + telemetryInterface311-16 (1635), + telemetryInterface311-2 (1636), + telemetryInterface311-3 (1637), + telemetryInterface311-4 (1638), + telemetryInterface311-5 (1639), + telemetryInterface311-6 (1640), + telemetryInterface311-7 (1641), + telemetryInterface311-8 (1642), + telemetryInterface311-9 (1643), + telemetryInterface312-1 (1644), + telemetryInterface312-10 (1645), + telemetryInterface312-11 (1646), + telemetryInterface312-12 (1647), + telemetryInterface312-13 (1648), + telemetryInterface312-14 (1649), + telemetryInterface312-15 (1650), + telemetryInterface312-16 (1651), + telemetryInterface312-2 (1652), + telemetryInterface312-3 (1653), + telemetryInterface312-4 (1654), + telemetryInterface312-5 (1655), + telemetryInterface312-6 (1656), + telemetryInterface312-7 (1657), + telemetryInterface312-8 (1658), + telemetryInterface312-9 (1659), + telemetryInterface313-1 (1660), + telemetryInterface313-10 (1661), + telemetryInterface313-11 (1662), + telemetryInterface313-12 (1663), + telemetryInterface313-13 (1664), + telemetryInterface313-14 (1665), + telemetryInterface313-15 (1666), + telemetryInterface313-16 (1667), + telemetryInterface313-2 (1668), + telemetryInterface313-3 (1669), + telemetryInterface313-4 (1670), + telemetryInterface313-5 (1671), + telemetryInterface313-6 (1672), + telemetryInterface313-7 (1673), + telemetryInterface313-8 (1674), + telemetryInterface313-9 (1675), + telemetryInterface314-1 (1676), + telemetryInterface314-10 (1677), + telemetryInterface314-11 (1678), + telemetryInterface314-12 (1679), + telemetryInterface314-13 (1680), + telemetryInterface314-14 (1681), + telemetryInterface314-15 (1682), + telemetryInterface314-16 (1683), + telemetryInterface314-2 (1684), + telemetryInterface314-3 (1685), + telemetryInterface314-4 (1686), + telemetryInterface314-5 (1687), + telemetryInterface314-6 (1688), + telemetryInterface314-7 (1689), + telemetryInterface314-8 (1690), + telemetryInterface314-9 (1691), + telemetryInterface315-1 (1692), + telemetryInterface315-10 (1693), + telemetryInterface315-11 (1694), + telemetryInterface315-12 (1695), + telemetryInterface315-13 (1696), + telemetryInterface315-14 (1697), + telemetryInterface315-15 (1698), + telemetryInterface315-16 (1699), + telemetryInterface315-2 (1700), + telemetryInterface315-3 (1701), + telemetryInterface315-4 (1702), + telemetryInterface315-5 (1703), + telemetryInterface315-6 (1704), + telemetryInterface315-7 (1705), + telemetryInterface315-8 (1706), + telemetryInterface315-9 (1707), + telemetryInterface316-1 (1708), + telemetryInterface316-10 (1709), + telemetryInterface316-11 (1710), + telemetryInterface316-12 (1711), + telemetryInterface316-13 (1712), + telemetryInterface316-14 (1713), + telemetryInterface316-15 (1714), + telemetryInterface316-16 (1715), + telemetryInterface316-2 (1716), + telemetryInterface316-3 (1717), + telemetryInterface316-4 (1718), + telemetryInterface316-5 (1719), + telemetryInterface316-6 (1720), + telemetryInterface316-7 (1721), + telemetryInterface316-8 (1722), + telemetryInterface316-9 (1723), + telemetryInterface317-1 (1724), + telemetryInterface317-10 (1725), + telemetryInterface317-11 (1726), + telemetryInterface317-12 (1727), + telemetryInterface317-13 (1728), + telemetryInterface317-14 (1729), + telemetryInterface317-15 (1730), + telemetryInterface317-16 (1731), + telemetryInterface317-2 (1732), + telemetryInterface317-3 (1733), + telemetryInterface317-4 (1734), + telemetryInterface317-5 (1735), + telemetryInterface317-6 (1736), + telemetryInterface317-7 (1737), + telemetryInterface317-8 (1738), + telemetryInterface317-9 (1739), + telemetryInterface501-1 (1740), + telemetryInterface501-2 (1741), + telemetryInterface511-1 (1742), + telemetryInterface511-2 (1743), + telemetryInterface521-1 (1744), + telemetryInterface521-2 (1745), + telemetryInterface531-1 (1746), + telemetryInterface531-2 (1747), + telemetryInterface541-1 (1748), + telemetryInterface541-2 (1749), + telemetryInterface551-1 (1750), + telemetryInterface551-2 (1751), + telemetryInterface561-1 (1752), + telemetryInterface561-2 (1753), + telemetryInterface571-1 (1754), + telemetryInterface571-2 (1755), + telemetryInterface581-1 (1756), + telemetryInterface581-2 (1757), + telemetryInterface591-1 (1758), + telemetryInterface591-2 (1759), + telemetryInterface601-1 (1760), + telemetryInterface601-2 (1761), + telemetryInterface611-1 (1762), + telemetryInterface611-2 (1763), + telemetryInterface621-1 (1764), + telemetryInterface621-2 (1765), + telemetryInterface631-1 (1766), + telemetryInterface631-2 (1767), + telemetryInterface641-1 (1768), + telemetryInterface641-2 (1769), + telemetryInterface651-1 (1770), + telemetryInterface651-2 (1771), + telemetryInterface661-1 (1772), + telemetryInterface661-2 (1773), + telemetryInterface671-1 (1774), + telemetryInterface671-2 (1775), + telemetryInterface681-1 (1776), + telemetryInterface681-2 (1777), + telemetryInterface691-1 (1778), + telemetryInterface691-2 (1779), + mnd (1780), + fopr (1781), + plct (1782), + plcr (1783), + tlct (1784), + tlcr (1785), + noInputPower (1786), + protshelf (1787), + ac1 (1788), + ac2 (1789), + qlink (1790), + laserFail (1791), + receiverfailure (1792), + pumplaserfail (1793), + equipmentnotaccepted (1794), + equipmentmismatch (1795), + equipmentnotapproved (1796), + fot (1797), + pccfail1 (1798), + pccfail2 (1799), + pccfail3 (1800), + pecloss (1801), + lscloss1 (1802), + lscloss2 (1803), + lscmismatch1 (1804), + lscmismatch2 (1805), + utifp (1806), + felne (1807), + txFailure (1808), + logOccupancyThresholdReached (1809), + logIsFull (1810), + cpuFailure (1811), + notEnoughProcesses (1812), + processDown (1813), + outOfSpace (1814), + excessiveError (1815), + dcf (1816), + remoteFailureIndication (1817), + timingReferenceFailure (1818), + systemClockHoldoverLonger (1819), + lossOfTimingOutput (1820), + syncSignalMessageMismatch (1821), + clockFailure (1822), + miscDiscInput1 (1823), + miscDiscInput2 (1824), + miscDiscInput3 (1825), + miscDiscInput4 (1826), + envOH (1827), + unitFailed (1828), + unitRemoval (1829), + unitTypeMismatch (1830), + oaInputLos (1831), + oaOutputLos (1832), + oaPowerFailure (1833), + oaPumpBiasOutRange (1834), + oaTemperatureOutOfRange (1835), + positiveSlip (1836), + negativeSlip (1837), + abnormalCondition (1838), + powerConsumptionOverload (1839), + authenticationFailed (1840), + resourceAccessDenied (1841), + telemetryInterface380-1 (1842), + rei (1843), + thresholdBSPlus15 (1844), + thresholdBSPlus24 (1845), + thresholdBSMinus15 (1846), + thresholdBSMinus24 (1847), + abnormalConditionEquip (1848), + lossOfHeartbeat (1849), + ethernetSwitchFail (1850), + preemphaseFail (1851), + channelUpgradeOrderViolation (1852), + remoteMsi (1853), + ltiT0-minor (1854), + ltiT4-minor (1855), + gainTiltProblem (1856), + ethernetLinkFault (1857), + remoteEthernetLinkFault (1858), + highPowerReceiveFailure (1859), + highPowerReceiveDetected (1860), + voltageProblem (1861), + voltageProblemLine (1862), + voltageProblemTrib1 (1863), + voltageProblemTrib2 (1864), + voltageProblemTrib3 (1865), + voltageProblemTrib4 (1866), + temperatureTooHighLine (1867), + temperatureTooHighTrib1 (1868), + temperatureTooHighTrib2 (1869), + temperatureTooHighTrib3 (1870), + temperatureTooHighTrib4 (1871), + calibrationFailure (1872), + calibrationFailureLine (1873), + calibrationFailureTrib1 (1874), + calibrationFailureTrib2 (1875), + calibrationFailureTrib3 (1876), + calibrationFailureTrib4 (1877), + redundantControllerFailed (1878), + flashCapacityProblem (1879), + inputLossOfLight (1880), + outputLossOfLight (1881), + feedbackAbsent (1882), + feedbackDegraded (1883), + missingOpticalModule1 (1884), + missingOpticalModule2 (1885), + missingOpticalModule3 (1886), + missingOpticalModule4 (1887), + unqualifiedOpticalModule1 (1888), + unqualifiedOpticalModule2 (1889), + unqualifiedOpticalModule3 (1890), + unqualifiedOpticalModule4 (1891), + coolingFan1Failure (1892), + coolingFan2Failure (1893), + coolingFan3Failure (1894), + coolingFan1Missing (1895), + coolingFan2Missing (1896), + coolingFan3Missing (1897), + swDownloadInOcu40Failed (1898), + noConnectionToOCU40 (1899), + swapPreparationFailure (1900), + noVCDBMigrationPossible (1901), + apsBackupRunning (1902), + channelCountMismatch (1903), + btbm (1904), + oscDirectionMismatch (1905), + regeneratorPairUnavailable (1906), + unspecifiedCriticalAlarm1 (1907), + unspecifiedCriticalAlarm2 (1908), + unspecifiedMajorAlarm1 (1909), + unspecifiedMajorAlarm2 (1910), + unspecifiedMinorAlarm1 (1911), + unspecifiedMinorAlarm2 (1912), + rxConnectedCardMismatch (1913), + lineCardFreqNotSupported (1914), + performanceLogThresholdReached (1915), + connectionLossToLocalNE (1916), + connectionLossToRemoteNE (1917), + communicationLossToOTS (1918), + communicationProblemToOTS (1919), + syncInProgress (1920), + storageFailure (1921), + criticalGeneralAlarm (1922), + noSyncMaster (1923), + alarmOn (1924), + overCurrent (1925), + lossOfMultiChannelSynchronisation (1926), + lossOfSynchronizationWord (1927), + noSlavePresent (1928), + partialLossOfMultiChannelSynchronisation (1929), + maximumInformationRate (1930), + firmwareMismatch (1931), + rpsConfigurationMismatch (1932), + measurementFailureFSU (1933), + lossOfSignalInput1 (1934), + lossOfSignalInput2 (1935), + lossOfSignalInput3 (1936), + lossOfSignalInput4 (1937), + wssModuleProblem (1938), + cardCommunicationFailure (1939), + fanMajor (1940), + fanMinor (1941), + missingOpticalModuleLine1 (1942), + unqualifiedOpticalModuleLine1 (1943), + sfpMissingP1 (1944), + sfpMissingP2 (1945), + sfpMissingP3 (1946), + sfpMissingP4 (1947), + sfpMissingLine1 (1948), + sfpMissingLine2 (1949), + sfpUnqualified1 (1950), + sfpUnqualified2 (1951), + sfpUnqualified3 (1952), + sfpUnqualified4 (1953), + sfpUnqualifiedLine1 (1954), + sfpUnqualifiedLine2 (1955), + lossOfFrameDelineationGFP (1956), + extensionHeaderMismatchGFP (1957), + userPayloadMismatchGFP (1958), + degradedSignal (1959), + clientSignalFailGFP (1960), + h73ApsMissing (1961), + otsApsMissing (1962), + mtxApsMissing (1963), + compactFlashFail (1964), + apsMismatchHiT75 (1965), + notificationQueueOverflowHiT75 (1966), + temperatureTooHighCritical (1967), + coolingFan11Failure (1968), + coolingFan12Failure (1969), + coolingFan21Failure (1970), + coolingFan22Failure (1971), + coolingFan31Failure (1972), + coolingFan32Failure (1973), + multipleFansFailure (1974), + mismatchOpticalModule1 (1975), + communicationLossToH73 (1976), + communicationProblemToH73 (1977), + subsystemMismatchH73 (1978), + coolingFan1CommFailure (1979), + coolingFan2CommFailure (1980), + coolingFan3CommFailure (1981), + alarmPanelFailure (1982), + alarmPanelMissing (1983), + powerControlSuspicious (1984), + ntpServerAccessFailed (1985), + probeLOSAsap (1986), + partnerSubagentMissing (1987), + powerEqualizationFail (1988), + sfpMissingP5 (1989), + sfpMissingP6 (1990), + sfpMissingP7 (1991), + sfpMissingP8 (1992), + sfpUnqualified5 (1993), + sfpUnqualified6 (1994), + sfpUnqualified7 (1995), + sfpUnqualified8 (1996), + lineRefClockProblem (1997), + fifoFlowProblem (1998), + noResponseReceived (2000), + necUploadOrResynchFailed (2001), + loopback (2002), + remotechassismismatch (2003), + remotechassismissing (2004), + localChassisConfiguring (2005), + localchassismismatch (2006), + localchassismissing (2007), + remoteChassisConfiguring (2008), + remoteEquipmentMismatch (2009), + localEquipmentMismatch (2010), + localConf (2011), + remoteConf (2012), + localVoltageTooLow (2013), + remoteVoltageTooLow (2014), + localVoltageTooHigh (2015), + remoteVoltageTooHigh (2016), + localTemperatureTooHigh (2017), + remoteTemperatureTooHigh (2018), + localPowerFail (2019), + localFanFailure (2021), + remoteFanFailure (2022), + protectionGroupProtectionFail (2023), + protectionGroupProtectionMismatch (2024), + laserTempTooHigh (2025), + laserTempTooLow (2026), + oopOoR (2027), + tempSafetyShutdown (2028), + shelfRemoved (2029), + shelfInserted (2030), + moduleInsert (2031), + moduleRemoved (2032), + plugRemoved (2033), + plugInserted (2034), + initConfignotAccepted (2035), + badBytesReceived (2036), + badPacketsReceived (2037), + gcccConnectionroblem (2039), + sfpmismatchport1 (2040), + sfpmismatchport2 (2041), + sfpmismatchport3 (2042), + sfpmismatchport4 (2043), + sfpmissingport1 (2044), + sfpmissingport2 (2045), + sfpmissingport3 (2046), + sfpmissingport4 (2047), + apsbackupfailed (2048), + mibs256required (2049), + lossofsequencesynchronization (2050), + t11BadSSM (2051), + t12BadSSM (2052), + t13BadSSM (2053), + t14BadSSM (2054), + t15BadSSM (2055), + t16BadSSM (2056), + t17BadSSM (2057), + t18BadSSM (2058), + dcf1 (2059), + dcf2 (2060), + rprMaxStationsExceeded (2061), + rprProtectionMisconfiguration (2062), + rprTopologyInconsistent (2063), + rprTopologyUnstable (2064), + rprRinglet0A0Exceeding (2065), + rprRinglet1A0Exceeding (2066), + rprMiscablingEast (2067), + rprMiscablingWest (2068), + rprLinkFailureEast (2069), + rprLinkFailureWest (2070), + sfpFailure (2071), + sfpMismatch (2072), + timingReferenceDegrade (2073), + memoryCardFailure (2074), + lineOrderError (2075), + sCCFModuleFailure (2076), + sCCFModuleAbsentAlarm (2077), + sfpmismatchport5 (2100), + sfpmismatchport6 (2101), + sfpmismatchport7 (2102), + sfpmismatchport8 (2103), + pathTraceMismatchAsap (2104), + onboardFlashFail (2105), + h73RecoverMode (2106), + mismatchOpticalModule2 (2107), + mismatchOpticalModule3 (2108), + mismatchOpticalModule4 (2109), + hdsApsMissing (2110), + communicationLossToHDS (2111), + communicationProblemToHDS (2112), + subsystemMismatchHDS (2113), + hdsRecoverMode (2114), + inputOpticalPowerTooLow (2115), + lossofsequencesynchronizationCom (2116), + radiusServerUnavailable (2117), + omdModuleProblem (2118), + overPowerRx (2119), + lossOfLight (2120), + overPowerTx (2121), + multiTransponderPowerFail (2122), + missingOpticalModule (2123), + mismatchOpticalModule (2124), + unqualifiedOpticalModule (2125), + reduceNotificationOverload (2126), + outputPortProblem (2127), + apsMissing (2128), + softwareManagementFailure (2129), + swapPreparationFailureProc (2130), + tIFActivatedAlarm1 (2131), + tIFActivatedAlarm2 (2132), + tIFActivatedAlarm3 (2133), + tIFActivatedAlarm4 (2134), + powerLossSuspicious (2135), + connectionEstablished (2136), + opticalPowerTransmittedTooLow (2137), + opticalPowerReceivedTooLow (2138), + problemOpticalModule (2139), + lossOfSignalGFP (2140), + dataRateMism (2141), + cltSignalFail (2142), + fwdDefectIndication (2143), + rmtDefectIndication (2144), + fanInsufficient (2145), + fanMismatch (2146), + coolingFan4Failure (2147), + coolingFan4Missing (2148), + powerOverLimit100G (2149), + uniMcuMissing (2150), + backupApsMissing (2151), + lossOfLaneAlign (2152), + lossOfMultiframeOPU (2153), + fanFilterMiss (2154), + eepromF (2155), + cltSignalFailGFP (2156), + tempProblemMajor (2157), + jnxOpticsLOS (2200), + jnxOpticsWavelenthLockErr (2201), + jnxOpticsPowerHighAlarm (2202), + jnxOpticsPowerLowAlarm (2203), + jnxOpticsBiasCurrentHighAlarm (2204), + jnxOpticsBiasCurrentLowAlarm (2205), + jnxOpticsTemperatureHighAlarm (2206), + jnxOpticsTemperaturelowAlarm (2207), + jnxOpticsTxPLLLockAlarm (2208), + jnxOpticsRxPLLLockAlarm (2209), + jnxOpticsAvgPowerAlarm (2210), + jnxOpticsRxLossAvgPowerAlarm (2211), + jnxOpticsLossofACPowerAlarm (2212), + jnxOpticsTxPowerHighThreshAlert (2213), + jnxOpticsTxPowerLowThreshAlert (2214), + jnxOpticsRxPowerHighThreshAlert (2215), + jnxOpticsRxPowerLowThreshAlert (2216), + jnxOpticsModuleTempHighThreshAlert (2217), + jnxOpticsModuleTempLowThreshAlert (2218), + jnxOpticsRxCarrierFreqHighThreshAlert (2219), + jnxOpticsRxCarrierFreqLowThreshAlert (2220), + jnxoptIfOtnLosAlarm (2221), + jnxoptIfOtnLofAlarm (2222), + jnxoptIfOtnLomAlarm (2223), + jnxoptIfOtuSsfAlarm (2224), + jnxoptIfOtuBdiAlarm (2225), + jnxoptIfOtuTimAlarm (2226), + jnxoptIfOtuIaeAlarm (2227), + jnxoptIfOtuBiaeAlarm (2228), + jnxoptIfOtuTsfAlarm (2229), + jnxoptIfOtuDegAlarm (2230), + jnxoptIfOtuFecExcessiveErrsAlarm (2231), + jnxoptIfOdukTcmOciAlarm (2232), + jnxoptIfOdukTcmLckAlarm (2233), + jnxoptIfOdukTcmBdiAlarm (2234), + jnxoptIfOdukTcmTimAlarm (2235), + jnxoptIfOdukTcmDegAlarm (2236), + jnxoptIfOdukTcmIaeAlarm (2237), + jnxoptIfOdukTcmCSfAlarm (2238), + jnxoptIfOdukTcmSSfAlarm (2239), + jnxoptIfOdukTcmTSfAlarm (2240), + jnxOverTemperature (2241), + jnxFruFailed (2242), + jnxFruNotifMismatch (2243), + jnxFruRemoval (2244), + jnxFruPowerOff (2245), + jnxFanFailure (2246), + jnxPowerSupplyFailure (2247), + sOEsysalmcorttxerr (2248), + alarmMSSF (2249), + alarmMSB1BIP (2250), + alarmMSREITCA (2251), + alarmMSRSB1BIPTCA (2252), + alarmMSRSB2BIPTCA (2253), + alarmHPSD (2254), + alarmHPSF (2255), + alarmHPRDIP (2256), + alarmHPRDIS (2257), + alarmHPRDIC (2258), + alarmHPB3BIP (2259), + alarmHPREITCA (2260), + alarmHPB3BIPTCA (2261), + alarmLPSD (2262), + alarmLPSF (2263), + alarmLPRDIP (2264), + alarmLPRDIS (2265), + alarmLPRDIC (2266), + alarmLPREIB3 (2267), + alarmLPREIV5 (2268), + alarmLPB3BIP (2269), + alarmLPV5BIP (2270), + alarmLPREIB3TCA (2271), + alarmLPREIV5TCA (2272), + alarmLPB3BIPTCA (2273), + alarmLPV5BIPTCA (2274), + signalfailure (2275), + alarmB1BIPS (2276), + alarmB2BIPL (2277), + alarmREILTCA (2278), + alarmB1BIPSTCA (2279), + alarmB2BIPLTCA (2280), + ssignalFailHigherOrderPath (2281), + alarmTIMHigherOrderPath (2282), + alarmRDIPPHigherOrderPath (2283), + alarmRDISPHigherOrderPath (2284), + alarmRDICPHigherOrderPath (2285), + alarmREIPHigherOrderPath (2286), + alarmB3BIPPHigherOrderPath (2287), + alarmREIPTCAHigherOrderPath (2288), + alarmB3BIPPTCAHigherOrderPath (2289), + alarmLOPVvirtualtributarypath (2290), + alarmAISVvirtualtributarypath (2291), + alarmSDVvirtualtributarypath (2292), + alarmSFVvirtualtributarypath (2293), + alarmUNEQVvirtualtributarypath (2294), + alarmPLMVvirtualtributarypath (2295), + alarmTIMVvirtualtributarypath (2296), + alarmRDIPVvirtualtributarypath (2297), + alarmRDISVvirtualtributarypath (2298), + alarmRDICVvirtualtributarypath (2299), + alarmB3REIVvirtualtributarypath (2300), + alarmV5REIVvirtualtributarypath (2301), + alarmB3BIPVvirtualtributarypath (2302), + alarmV5BIPVvirtualtributarypath (2303), + alarmB3REIVTCAvirtualtributarypath (2304), + alarmV5REIVTCAvirtualtributarypath (2305), + alarmB3BIPVTCAvirtualtributarypath (2306), + alarmV5BIPVTCAvirtualtributarypath (2307), + alarmENETFCEERROR (2308), + alarmENETDROPFRTCA (2309), + alarmaisM13 (2310), + alarmE3T3LINEPCBITS (2311), + syslogAuthenticationFailure (2500), + syslogConnectionFailure (2501), + alarmShelfMismatch (3000), + alarmHwFailure (3001), + alarmPowerMissing (3002), + alarmCurrentTooLow (3003), + alarmCurrentTooHigh (3004), + alarmTransmittedDisabledIdle (3005), + alarmTransmittedDisabledAis (3006), + alarmCardRemoved (3007), + alarmSwitchFailed (3008), + alarmPowerSupplyUnitFailure (3009), + alarmInputVoltageFailure (3010), + alarmAlsPulsesReceived (3011), + alarmIdleSignalReceived (3012), + alarmLossOfReceiverClockRecovery (3013), + alarmOpticalInputPwrReceivedTooLow (3014), + alarmOpticalInputPwrReceivedTooHigh (3015), + alarmOpticalOutputPwrTransmittedTooHigh (3016), + alarmOpticalOutputPwrTransmittedTooLow (3017), + alarmSectionTraceInconsistency (3018), + alarmIndicationSignalOdu (3019), + alarmIndicationSignalOtu (3020), + alarmLossOfMultiFrameOtu (3021), + alarmAutomaticShutdownByAisOtu (3022), + alarmTraceIdentifierMismatchOtu (3023), + alarmSignalDegradeOtu (3024), + alarmBackwardDefectIndicationOtu (3025), + alarmAutomaticShutdownByAisOdu (3026), + alarmLOFLOMODU (3027), + alarmOpenConnectionIndicationOdu (3028), + alarmLockedDefectOdu (3029), + alarmTraceIdentifierMismatchOdu (3030), + alarmSignalDegradeOdu (3031), + alarmBackwardDefectIndicationOdu (3032), + alarmMultiplexStructureIdentifierMismatchOPU (3033), + alarmAPSCONF (3034), + alarmAutomaticShutdownbyEPC (3035), + alarmFacilityDataRateNotSupported (3036), + alarmApsProtocolFailure (3037), + alarmPeerLink (3038), + alarmPayloadMismatchOPU (3039), + alarmAttOnReceiverFiberLowerThanMonitor (3040), + alarmAttOnReceiverFiberHigherThanMonitor (3041), + alarmSignalDegradeOlm (3042), + alarmLossOfFrameMux (3043), + alarmLossOfFrameMuxFarEnd (3044), + alarmThres15MinExceededPhysConvCV (3045), + alarmThres15MinExceededPhysConvDE (3046), + alarmThres15MinExceededPhysConvES (3047), + alarmTSUBTEMPFHT (3048), + alarmSignalDegradationonLinkVector (3049), + alarmSignalFailureonLinkVector (3050), + alarmThres15MinExceededOtuES (3051), + alarmThres15MinExceededOtuSES (3052), + alarmThres15MinExceededOtuUAS (3053), + alarmThres15MinExceededOduES (3054), + alarmThres15MinExceededOduSES (3055), + alarmThres15MinExceededOduUAS (3056), + alarmAlarmIndicationSignalOduTcmA (3057), + alarmAlarmIndicationSignalOduTcmB (3058), + alarmOpenConnectionIndicationOduTcmA (3059), + alarmOpenConnectionIndicationOduTcmB (3060), + alarmTraceIdentifierMismatchOduTcmA (3061), + alarmTraceIdentifierMismatchOduTcmB (3062), + alarmLockedDefectOduTcmA (3063), + alarmLockedDefectOduTcmB (3064), + alarmLossofTandemConnectionOduTcmB (3065), + alarmLossofTandemConnectionOduTcmA (3066), + alarmSignalDegradeOduTcmB (3067), + alarmSignalDegradeOduTcmA (3068), + alarmBackwardDefectIndicationOduTcmA (3069), + alarmBackwardDefectIndicationOduTcmB (3070), + alarmThres15MinExceededOduTcmAES (3071), + alarmThres15MinExceededOduTcmBES (3072), + alarmThres15MinExceededOduTcmASES (3073), + alarmThres15MinExceededOduTcmBSES (3074), + alarmThres15MinExceededOduTcmAUAS (3075), + alarmThres15MinExceededOduTcmBUAS (3076), + alarmThres15MinExceededOduTcmABbe (3077), + alarmThres15MinExceededOduTcmBBbe (3078), + alarmThres15MinExceededOtuBbe (3079), + alarmThres15MinExceededOduBbe (3080), + alarmEquipmentNotSupportedByPhysicalLayer (3081), + autoShutdownLaserOffDueToHighTemp (3082), + autoShutdownLaserOffDueToHighTxPwr (3083), + laserEndOfLife (3084), + midstageFault (3085), + laserBiasCurrAbnormal (3086), + opticalPowerTxLOS (3087), + farEndIpAddressUnknown (3088), + topologyDataCalculationInProgres (3089), + topologyDataInvalid (3090), + ntpServer1Unreachable (3091), + ntpServer2Unreachable (3092), + ntpServer3Unreachable (3093), + autoShutdownLaserOffDueToErrFwd (3094), + autoShutdown (3095), + autoShutdownAlS (3096), + autoShutdownSendingIdle (3097), + autoShutdownSendingAisLine (3098), + alarmOosManagement (3099), + alarmOosMaintenance (3100), + alarmOosDisabled (3101), + alarmLossOfCharSyncFromFarEnd (3102), + alarmLossofMultiframeHigherOrderPath (3103), + alarmLossofSequenceHigherOrderPath (3104), + alarmIndicationSignalHigherOrderPath (3105), + alarmLossOfPointerHigherOrderPath (3106), + alarmUnequippedHigherOrderPath (3107), + alarmPayloadMismatchHigherOrderPath (3108), + alarmRemoteDefectIndicationHigherOrderPath (3109), + alarmTerminalLoopback (3110), + alarmFacilityLoopback (3111), + alarmFacilityForcedOn (3112), + alarmReceiverDisabled (3113), + alarmTransmitterDisabledOff (3114), + alarmAutoShutdownLaserOffDueToErrFwd (3115), + alarmLaserBiasCurrAbnormal (3116), + alarmSwitchtoProtectionInhibited (3117), + alarmSwitchtoWorkingInhibited (3118), + alarmIndicationSignalLine (3119), + alarmRemoteDefectIndicationLine (3120), + alarmSignalDegradeLine (3121), + alarmLossofMultiframeLowerOrderPath (3122), + alarmLossofSequenceLowerOrderPath (3123), + alarmIndicationSignalLowerOrderPath (3124), + alarmLossOfPointerLowerOrderPath (3125), + alarmUnequippedLowerOrderPath (3126), + alarmRemoteDefectIndicationLowerOrderPath (3127), + alarmPayloadMismatchLowOrderPath (3128), + alarmlossOfTransmitterClockRecovery (3129), + alarmelasticStoreOverflowTransmitter (3130), + alarmthermoElectricCoolerEndOfLife (3131), + alarmlossOfSignalTransmitter (3132), + alarmattOnTransmitterFiberLowerThanMonitor (3133), + alarmsectionSignalFailure (3134), + alarmsignalDegradeHigherOrderPath (3135), + alarmlossOfMultiframeVCG (3136), + alarmlossOfSequenceVCG (3137), + alarmlossofAlignmentVCG (3139), + alarmremoved (3140), + alarmthres15MinExceededPhysConvCVDE (3141), + alarmoTDRMeasuringinProgress (3142), + alarmprotectionNotAvailable (3143), + alarmembeddedOperationsChannelFailure (3144), + alarmsignalDegradeSection (3145), + alarmapdLowVoltage (3146), + alarmapdHighVoltage (3147), + alarmlinkControlProtocolFailure (3148), + alarmthermoElectricCoolerCurrentTooLow (3149), + alarmthermoElectricCoolerCurrentTooHigh (3150), + alarmreceiverOverloadProtection (3151), + alarmautoShutdownSendingAisOpu (3152), + alarmalarmIndicationSignalOpu (3153), + alarmattOnTransmitterFiberHigherThanMonitor (3154), + alarmOosAins (3155), + alarmSubModuleTempTooHigh (3156), + alarmAlarmIndicationSignalOduTcmC (3157), + alarmOpenConnectionIndicationOduTcmC (3158), + alarmLockedDefectOduTcmC (3159), + alarmLossofTandemConnectionOduTcmC (3160), + alarmSignalDegradeOduTcmC (3161), + alarmBackwardDefectIndicationOduTcmC (3162), + alarmIntrusionRx (3163), + alarmIntrusionTx (3164), + alarmLaserBiasCurrentNormalizedtooHigh (3165), + alarmThirdPartyPlug (3166), + loopbackError (3167), + traceIdentifierMismatchOtu (3168), + traceIdentifierMismatchOdu (3169), + traceIdentifierMismatchOduTcmA (3170), + traceIdentifierMismatchOduTcmB (3171), + traceIdentifierMismatchOduTcmC (3172), + peerConfigMismatch (3173), + alarmMismatch (3174), + alarmEquipmentNotAccepted (3175), + alarmEquipmentNotApproved (3176), + alarmEquipmentMismatch (3177), + alarmTemperatureTooHigh (3178), + alarmTemperatureTooLow (3179), + alarmLaserTemperatureTooLow (3180), + alarmLaserTemperatureTooHi (3181), + alarmLossOfFrameOtu (3182), + alarmMultiplexStructureIdentifierMismatchOPU1 (3183), + alarmLossOfFrame (3184), + alarmLossOfGfpFrame (3185), + alarmPayloadMismatchGfp (3186), + alarmGfpLossOfClientSig (3187), + alarmMultipleFanFailure (3188), + alarmSingleFanFailure (3189), + alarmExternalLinkFailure (3190), + alarmLossOfCharSync (3191), + alarmSectionTraceMismatch (3192), + alarmOIPtooHigh (3193), + alarmOOPtooLow (3194), + alarmRxLineAttenuationOoR (3195), + alarmTxLineAttenuationOoR (3196), + alarmOIPtooLow (3197), + alarmOOPtooHigh (3198), + alarmOOPOoR (3199), + alarmIfModTempOoR (3200), + alarmLaserTempOoR (3201), + alarmLossofOOP (3202), + alarmLossofSignalonTxport (3203), + alarmPlannedModuleMismatch (3228), + alarmRxLossofClock (3229), + alarmOtuFecLossofFrame (3230), + alarmLineAIS (3232), + alarmLineANotAvailable (3233), + alarmLineBNotAvailable (3234), + alarmLineRDI (3235), + alarmLossofOIP (3236), + alarmNoFeedback (3238), + alarmRxSignalOverload (3239), + alarmPathAIS (3242), + alarmPathPLM (3243), + alarmPathRDI (3244), + alarmPathSignalDegrade (3245), + alarmPathUNEQ (3246), + alarmPlannedModuleMissing (3247), + alarmProtectionGroupFailure (3248), + alarmSectionSignalDegrade (3249), + alarmSectionTraceInconsistency1 (3250), + alarmSectionTraceMismatch1 (3251), + alarmSubModuleTempOoR (3252), + alarmSwitchPositionError (3253), + alarmExternalInput1 (3254), + alarmExternalInput10 (3255), + alarmExternalInput11 (3256), + alarmExternalInput12 (3257), + alarmExternalInput2 (3258), + alarmExternalInput3 (3259), + alarmExternalInput4 (3260), + alarmExternalInput5 (3261), + alarmExternalInput6 (3262), + alarmExternalInput7 (3263), + alarmExternalInput8 (3264), + alarmExternalInput9 (3265), + alarmSectionCV15Minutes (3266), + alarmPathCV15Minutes (3267), + alarmSectionCV24Hours (3268), + alarmPathCV24Hours (3269), + alarmSectionES15Minutes (3270), + alarmPathES15Minutes (3271), + alarmPathES24Hours (3272), + alarmHighCurrentThresholdCrossed (3273), + alarmHighestCurrentThresholdCrossed (3274), + alarmHighestOIPThresholdCrossed (3275), + alarmHighestOOPThresholdCrossed (3276), + alarmHighestTemperatureThresholdCrossed (3277), + alarmHighestVoltageThresholdCrossed (3278), + alarmHighOIPThresholdCrossed (3279), + alarmHighOOPThresholdCrossed (3280), + alarmHighTemperatureThresholdCrossed (3281), + alarmHighVoltageThresholdCrossed (3282), + alarmLowCurrentThresholdCrossed (3283), + alarmLowestCurrentThresholdCrossed (3284), + alarmLowestOIPThresholdCrossed (3285), + alarmLowestOOPThresholdCrossed (3286), + alarmLowestTemperatureThresholdCrossed (3287), + alarmLowestVoltageThresholdCrossed (3288), + alarmLowOIPThresholdCrossed (3289), + alarmLowOOPThresholdCrossed (3290), + alarmLowTemperatureThresholdCrossed (3291), + alarmLowVoltageThresholdCrossed (3292), + alarmSectionSEFS15Minutes (3293), + alarmSectionSEFS24Hours (3294), + alarmSectionSES15Minutes (3295), + alarmPathSES15Minutes (3296), + alarmPathSES24Hours (3297), + alarmPathUAS15Minutes (3298), + alarmPathUAS24Hours (3299), + alarmFanPowerSupply1Failure (3300), + alarmFanPowerSupply2Failure (3301), + alarmPowerSupplyFailure (3302), + alarmGFPLOF (3303), + alarmGFPPLM (3304), + alarmGFPLossofClientSignal (3305), + alarmGFPLossofCharacterSync (3306), + alarmGFPTClientSignalFailure (3307), + alarmRSTIM (3308), + alarmAIS (3309), + alarmLinkDown (3310), + alarmAUAIS (3311), + alarmAULOP (3312), + alarmHPRDI (3313), + alarmHPPLM (3314), + alarmHPUNEQ (3315), + alarmTUAIS (3316), + alarmTULOP (3317), + alarmLPRDI (3318), + alarmLPPLM (3319), + alarmLPUNEQ (3320), + alarmTULOM (3321), + alarmMSAIS (3322), + alarmMSRDI (3323), + alarmMSSD (3324), + alarmPowerFail (3325), + alarmInternalHWFailure (3326), + fwpMismatchDownloadServiceAffecting (3327), + fwpMismatchDownloadNotServiceAffecting (3328), + transmitterDisabledEpc (3329), + linefailure (3330), + thres15MinExceededFecCE (3331), + thres15MinExceededFecUBE (3332), + thres15MinExceededFecES (3333), + thres15MinExceededFecSES (3334), + thres15MinExceededMuxES (3335), + thres15MinExceededMuxSES (3336), + thres15MinExceededGfpCHEC (3337), + thres15MinExceededGfpTHEC (3338), + thres15MinExceededGfpTHecDisc (3339), + thres15MinExceededGfpTsuperblockDisc (3340), + databaseMismatch (3341), + databaseNcuMismatch (3342), + serverSignalFailureSectionRS (3343), + databaseVersionMismatch (3344), + dcnCommunicationFail (3345), + clientFailForwarding (3346), + virtualChannelAis (3347), + serverSignalFailureVf (3348), + signalFailureOnLink (3349), + serverSignalFailureGfp (3350), + serverSignalFailurePath (3351), + gainTiltNotSettable (3352), + txPowerLimited (3353), + equalizationProgress (3354), + uPortFailure (3355), + autoShutdownBlock (3356), + serverSignalFailTx (3357), + pLMVF (3358), + voaControlFail (3359), + provisioningLocked (3360), + mansw (3361), + wtrTimerRunning (3362), + pcsSignalDegrade (3363), + alarmInputTIF (3364), + thres15MinExceededSonetSectES (3365), + thres15MinExceededSonetSectSES (3366), + thres15MinExceededSonetSectSEFS (3367), + thres15MinExceededSonetSectCV (3368), + thres15MinExceededSonetLineES (3369), + thres15MinExceededSonetLineSES (3370), + thres15MinExceededSonetLineCV (3371), + thres15MinExceededSonetLineUAS (3372), + thres15MinExceededOduTcmAES (3373), + thres15MinExceededOduTcmASES (3374), + thres15MinExceededOduTcmAUAS (3375), + thres15MinExceededOduTcmABBE (3376), + thres15MinExceededOduTcmBES (3377), + thres15MinExceededOduTcmBSES (3378), + thres15MinExceededOduTcmBUAS (3379), + thres15MinExceededOduTcmBBBE (3380), + thres15MinExceededOduTcmCES (3381), + thres15MinExceededOduTcmCSES (3382), + thres15MinExceededOduTcmCUAS (3383), + thres15MinExceededOduTcmCBBE (3384), + thres15MinExceededOtuES (3385), + thres15MinExceededOtuSES (3386), + thres15MinExceededOtuUAS (3387), + thres15MinExceededOtuBBE (3388), + thres15MinExceededOduES (3389), + thres15MinExceededOduSES (3390), + thres15MinExceededOduUAS (3391), + thres15MinExceededOduBBE (3392), + thresOptPowerCtrlFailureLow (3393), + thresOptPowerCtrlFailureHigh (3394), + dcnServerSignalFailure (3395), + maxPowerConsEquipModulesToHigh (3396), + maxPowerConsProvModulesToHigh (3397), + equipmentMismatchAllow (3398), + oosPrePostSig (3399), + linkFailureNOSReceiveState (3400), + linkFailureNOSTransmitState (3401), + linkFailureNOSReceiveStateEgress (3402), + linkFailureNOSTransmitStateEgress (3403), + linkFailureCount15 (3404), + linkFailureCount24 (3405), + lossOfSynchronizationCount15 (3406), + lossOfSynchronizationCount24 (3407), + lossOfSignalCount15 (3408), + lossOfSignalCount24 (3409), + gfpExtHeaderMismatch (3410), + gfpUserPayloadMismatch (3411), + linkStateMismatch (3412), + connectionCableFail (3413), + temperatureProblemMinor (3414), + wrongLaserSafetyBusCabling (3415), + multiplexStructureIdentifierMismatch (3416), + lossOfFrameAndMultiframe (3417), + temperatureProblemMajor (3418), + onboardFlashFailure (3419), + noLightDetected (3420), + internalTraceIdentifierMismatch (3421), + channelMismatch (3422), + preemphasisSectionFail (3423), + degradedSignalDeg (3424), + ssfProtection (3425), + syncFailure (3426), + moduleTypeMismatch (3427), + boosterStageTransmitFail (3428), + preamplifierStageTransmitFail (3429), + boosterStageReceiveFail (3430), + oscTransmitDegrade (3431), + pump1TransmitDegrade (3432), + pump1TransmitFail (3433), + pump2TransmitDegrade (3434), + pump2TransmitFail (3435), + pump3TransmitDegrade (3436), + pump3TransmitFail (3437), + pump4TransmitDegrade (3438), + pump4TransmitFail (3439), + slotLSBMismatch (3440), + gfpAlarmIndicationSignal (3441), + gfpClientSignalFailLossOfCharacterSynchronisation (3442), + gfpClientSignalFailLossOfSignal (3443), + gfpNoFramesReceived (3444), + gfpOutOfSequence (3445), + gfpUnexpectedChannelID (3446), + gfpDataRateMismatch (3447), + degreeOfPolarization (3448), + inputPowerLow (3449), + overPower1M (3450), + outputPowerLow (3451), + subBandLossOfSignal (3452), + lowCFSUFlow (3453), + measurementFailed (3454), + clientModeMismatch (3455), + moduleProblem (3456), + powerOutOfRange (3457), + functionNotSupported (3458), + lossOfPRBSLock (3459), + filterExpired (3460), + opticalPreamplifierReceiveFailure (3461), + shelfMissing (3462), + dopFail (3463), + tdcControlLoopLimit (3464), + pmdFail (3465), + pumpDegrade (3466), + pumpFail (3467), + wrongShelfType (3468), + lossOfClockLock (3469), + rAMFull (3470), + mIBFullMinor (3471), + mIBFullMajor (3472), + compactFlashFull (3473), + lossOfTimeReference (3474), + fanFilterMissing (3475), + overflow (3476), + lnkDown (3477), + duplicatedDHCPServer (3478), + tl1NotificationQueueOverflow (3479), + vpnConnectionFail (3480), + iLANFail (3481), + ramanGainDegraded (3482), + ramanGainFail (3483), + subsysMissing (3484), + pwrControlSuspicious (3485), + pwrEqualizationFail (3486), + pwrLossSuspicious (3487), + preemphasisFail (3488), + clientSignalFail (3489), + forwardDefectIndication (3490), + remoteDefectIndication (3491), + eEPROMFail (3492), + thresholdMaxInputSpanLoss15 (3493), + thresholdMaxInputSpanLoss24 (3494), + compactFlashInsufficientSize (3495), + controllerInterfaceFail (3496), + lOpen (3497), + compactFlashMissing (3498), + pLLUn (3499), + oosPrePostSigInSetUpProcess (3500), + oosPrePostSigInTearDownProcess (3501), + cpTunnelModificationInProgress (3502), + capabilityLevelMismatch (3503), + oosPrePostSigEstablishFailed (3504), + oosPrePostSigAfterPrecompFailed (3505), + cpTunnelEstablishFailed (3506), + cpTunnelPrecompFailed (3507), + localFault (3508), + oscPwrTooHigh (3509), + oscPwrTooLow (3510), + aseTableBuild (3511), + aseTableNotAvailable (3512), + automaticPowerReduction (3513), + highBer (3514), + pumpLaser1TempTooHigh (3515), + pumpLaser1TempTooLow (3516), + pumpLaser2TempTooHigh (3517), + pumpLaser2TempTooLow (3518), + ospfIpServerNotAvailable (3519), + lossOsc (3520), + brPwrRxTooHigh (3521), + aseTableGenFailSignalInput (3522), + aseTableGenFailOscMissing (3523), + aseTableGenFailHighBackreflection (3524), + ramanPumpPwrTooHigh (3525), + ramanPumpPwrTooLow (3526), + autoPowerShutdown (3527), + aseTableGenFailLow (3528), + aseLow (3529), + configurableOpticalOutputPowerTransmittedTooHigh (3530), + configurableOpticalOutputPowerTransmittedTooLow (3531), + lossAttProgress (3532), + aseTableGenProcess (3533), + faultOnOpm (3534), + optSignalFailure (3535), + opmAbnormalCondition (3536), + hwOprReachedHT (3537), + disabledChannelPowerTooHigh (3538), + lossOfSignalCPort (3539), + serverSignalFailureODU (3540), + signalFailureOPU (3541), + serverSignalReduced (3543), + dispersionCompensationTooLow (3544), + dispersionCompensationTooHigh (3545), + farEndCommFailure (3546), + alarmTurnupCondition (3547), + alarmTurnupFailed (3548), + alarmDispertionTunningCondition (3549), + linkAttenuationTooLow (3550), + linkAttenuationTooHigh (3551), + entityOutageIndication (3552), + fiberConnectionMissing (3553), + farEndInformationMismatch (3554), + automaticPowerReductionForEyeSafety (3555), + lossOfPilotSignal (3556), + pumpLaser3TempTooHigh (3557), + pumpLaser3TempTooLow (3558), + pilotReceiveLevelHigh (3559), + autoShutdownStbyProtection (3560), + databaseFailure (3561), + latencyTooHigh (3562), + latencyTooLow (3563), + thres15MinExceededFecBERCE (3564), + alarmMepNotPresentL2 (3565), + alarmPriVidNotEqualExtVidL2 (3566), + alarmInputTIF1 (3567), + alarmInputTIF2 (3568), + alarmInputTIF3 (3569), + alarmInputTIF4 (3570), + alarmInputTIF5 (3571), + alarmInputTIF6 (3572), + alarmInputTIF7 (3573), + alarmInputTIF8 (3574), + alarmInputTIF9 (3575), + alarmInputTIF10 (3576), + alarmInputTIF11 (3577), + alarmInputTIF12 (3578), + alarmInputTIF13 (3579), + alarmInputTIF14 (3580), + alarmInputTIF15 (3581), + alarmInputTIF16 (3582), + alarmOutputTIF1 (3583), + alarmOutputTIF2 (3584), + alarmOutputTIF3 (3585), + alarmOutputTIF4 (3586), + schedEqlzNeedsNTP (3587), + autoShutdownODU-CLK (3588), + alarmNTPnotSynchronized (3589), + tamperEvent (3590), + cryptoOfficerPWmissing (3591), + alarmCRY-PWcannotBeEntered (3592), + authPWmissing (3593), + maxKeyexchDegrade (3594), + maxKeyExchFail (3595), + encryptionSwitchedOff (3596), + keyExchangedForced (3597), + routeTripDelayTooHigh (3598), + routeTripDelayTooLow (3599), + airDustFilterClogged (3600), + alarmOSC-Opt-CTRL-Fail-High (3601), + alarmOSC-Opt-CTRL-Fail-Low (3602), + amplifierAbnormal (3603), + alarmASE-tab-gen-failed-PILOT (3604), + laser-4-TempTooHigh (3605), + laser-4-TempTooLow (3606), + alarmFWD-ASE-PIL-Force-Fail (3607), + force-FWD-ASE-Pilot-ON (3608), + inputVoltageFailure-1 (3609), + inputVoltageFailure-2 (3610), + xfpDecisionThresSetFailed (3611), + thres15MinExceededPhysConvSE (3612), + thres15MinExceededPhysConvESTX (3613), + thres15MinExceededPhysConvCVTX (3614), + thres15MinExceededPhysConvSETX (3615), + prbsRcvActivated (3616), + prbsTrmtActivated (3617), + prbsLossOfSeqSynch (3618), + clientSignalFailOpu (3619), + lossOfTestSeqSynchOpu (3620), + autoShutdownOpuClientSignalFail (3621), + localOscTemperatureTooLow (3622), + localOscTemperatureTooHigh (3623), + differentialGroupDelayTooLow (3624), + differentialGroupDelayTooHigh (3625), + chromaticDispersionTooLow (3626), + chromaticDispersionTooHigh (3627), + signalToNoiseRatioTooLow (3628), + localOscLevelAbnormal (3629), + carrierFreqOffsetTooLow (3630), + carrierFreqOffsetTooHigh (3631), + lossOfLane (3632), + alarmSfCfmLevel0L2 (3633), + alarmSfCfmLevel1L2 (3634), + alarmSfCfmLevel2L2 (3635), + alarmSfCfmLevel3L2 (3636), + alarmSfCfmLevel4L2 (3637), + alarmSfCfmLevel5L2 (3638), + alarmSfCfmLevel6L2 (3639), + alarmSfCfmLevel7L2 (3640), + alarmSwitchtoWorkingInhibitedL2 (3641), + cfmRemoteDefectIndication (3642), + cfmCcmMacStatus (3643), + cfmCcmError (3644), + cfmCcmLost (3645), + cfmCcmXConn (3646), + messageLossSpeq (3647), + oscFiberMissingSpeq (3648), + optLowSpeq (3649), + ppcOutOfRangeSpeq (3650), + gainTooHighSpeq (3651), + gainTooLowSpeq (3652), + gainAdoptFailedSpeq (3653), + alarmSwitchtoProtectionInhibitedL2 (3654), + laserOnDelay (3655), + serverSignalFailureODUcrs (3656), + autoShutdownSendingOciOdu (3657), + oduTribMsiMismatch (3658), + meaChannelMismatch (3659), + alarmAutoShutdownTxRxLasersDueToHighTemp (3660), + alarmEncryptionModuleFwpUpdateEnabled (3661), + alarmEncryptionModuleSelfTestStarted (3662), + alarmEncryptionModuleSelfTestFail (3663), + alarmEncryptionModuleSelfTestFailCritical (3664), + alarmEncryptionPortEncryptionSwitchOffEnabled (3665), + encryptionPortKeyInitExchgMissed (3666), + eqlzAdjust (3667), + hwDegrade (3668), + hwInitializing (3669), + ampFailure (3670), + autoAmpShutdown (3671), + fiberConnLos (3672), + fiberConnOptFault (3673), + fiberConnInvalid (3674), + fiberConnMismatch (3675), + fiberConnCommError (3676), + fiberConnProtocolFailure (3677), + fiberConnDataFailure (3678), + fiberAttenuationHigh (3679), + fiberConnInvalidTx (3680), + fiberConnMismatchTx (3681), + fiberAttenuationHighTx (3682), + switchToDuplexInhibited (3683), + meaSwRevision (3684), + dbReplicationIncompleted (3685), + backupNotResponding (3686), + backupForcedToHalt (3687), + duplexLinkFailure (3688), + provPayloadMismatch (3689), + autoShutdownOpuFlxCSF (3690), + ogicalLanesSkewTooHigh (3691), + fiberAttenuationCond (3692), + advaplct (3850), + advatlct (3851), + advaplcr (3852), + advatlcr (3853), + advareil (3854), + advaexcl (3855), + advadegl (3856), + advatims (3857), + advaaisp (3858), + advalopp (3859), + advatimp (3860), + advauneqp (3861), + advaplmp (3862), + advalomp (3863), + advaexcp (3864), + advadegp (3865), + advareip (3866), + advarfip (3867), + lcascrc (3868), + advasqm (3869), + gidmismatch (3870), + advamnd (3871), + advaaisv (3872), + advalopv (3873), + advatimv (3874), + advauneqv (3875), + advaplmv (3876), + advaexcv (3877), + advadegv (3878), + advareiv (3879), + advarfiv (3880), + rmtinitlpbk (3881), + advarai (3882), + advarei (3883), + advaidle (3884), + advacsf (3885), + gfplfd (3886), + gfpuplmismatch (3887), + gfpexhmismatch (3888), + vcatlom (3889), + fragileecc (3890), + pwrlofs (3891), + pwlof (3892), + pwlatefrm (3893), + pwjbovrn (3894), + unresolvedsatop (3895), + hwcfginconsistent (3896), + advaais (3900), + allsyncref (3901), + autonegunknown (3902), + avghldovrfrqnotrdy (3903), + bckupntpsvrFailed (3904), + bwexceedednegspeed (3905), + crossconnectccm (3906), + ctneqpt (3907), + efmfail (3908), + efmrce (3909), + efmrld (3910), + efmrls (3911), + erroneousccm (3912), + esmcfail (3913), + forced (3914), + freqoff (3915), + frngsync (3916), + fstsync (3917), + hldovrsync (3918), + ipaddrconflict (3919), + lcpfail (3920), + lcploopback (3921), + lnkdeactivated (3922), + lnkdn (3923), + lnkdownautonegfailed (3924), + lnkdowncablefault (3925), + lnkdowncableremoved (3926), + lnkdownlpbkfault (3927), + lnkdownmasterslavecfg (3928), + lnkdownunisolated (3929), + lockout (3930), + advalof (3931), + advalos (3932), + losloc (3933), + primntpsvrFailed (3934), + qlinvalid (3935), + qlmismatch (3936), + qlsqlch (3937), + advarfi (3938), + rmtefmlpbkfail (3939), + rxjabber (3940), + shaperbtd (3941), + somemacstatus (3942), + somerdi (3943), + someremotemepccm (3944), + syncnotready (3945), + syncref (3946), + syncreffrc (3947), + syncreflck (3948), + syncrefman (3949), + syncrefwtr (3950), + dyinggasp (3951), + eqptflt (3952), + eqptremoved (3953), + intctneqpt (3954), + mismatch (3955), + overtemp (3956), + overvoltage (3957), + pwrnoinputunitfault (3958), + advasfpinserted (3959), + advasfpmismatch (3960), + advasfpnonqualified (3961), + advasfpremoved (3962), + advasfptxfault (3963), + snmpdghostresourcesbusy (3964), + snmpdghostunresolved (3965), + undertemp (3966), + undervoltage (3967), + dbftfail (3968), + dbftip (3969), + dbdowngradeip (3970), + genfilexferip (3971), + genoperip (3972), + swdlactip (3973), + swdlftip (3974), + swdlinstip (3975), + swdlvalip (3976), + testalarm (3977), + advaxfptxfault (3978), + advaxfpmismatch (3979), + advaxfpnonqualified (3980), + advaxfpremoved (3981), + acoopr (3982), + trafficfail (3983), + advaclockfail (3984), + rdncyswvermismatch (3985), + rdncyoutofsync (3986), + rdncylockout (3987), + rdncymaintenance (3988), + lagmbrfail (3989), + swdlproip (3990), + dbproip (3991), + swdlrvtip (3992), + dbcorruption (3993), + bpmismatch (3994), + vcgfail (3995), + advaloa (3996), + sqnc (3997), + advaaisl (3998), + advarfil (3999), + lossAtApplicationInterface (4000), + underCurrent (4001), + sCCommunicationFailure (4500), + switchFabricWithoutProtection (4501), + switchFabricNotEnough (4502), + lossOfLaneAlignment (4503), + thresholdCrossed (4504), + neNameMismatch (4505), + apcdFail (4506), + gainTiltProb (4507), + lossOfOPUMultiframeIndicator (4508), + failureOfProtocolProvisioningMismatch (4509), + failureOfProtocolNoResponse (4510), + lossTimingInput (4511), + thresholdMaxDM15 (4512), + thresholdMaxDM24 (4513), + protectionRoleMismatch (4514), + gfpClientSignalFail (4515), + apsVersionMismatch (4516), + fanInsuf (4517), + opuClientSignalFail (4518), + passwordExpiresSoon (4519), + maximumNumberOfUnsuccessfulLogins (4520), + poolBaseMismatch (4521), + poolPortBaseMismatch (4522), + fanMism (4523), + applicationCodeMismatch (4524), + cardVariantMismatch (4525), + mateCardClockFailure (4526), + iLANRingBroken (4527), + sLANRingBroken (4528), + thresholdFCSErrorsRx15 (4529), + thresholdFCSErrorsRx24 (4530), + thresholdFCSErrorsTx15 (4531), + thresholdFCSErrorsTx24 (4532), + testFailed (4533), + switchingFabricLinkCommunicationFailure (4534), + aPSLinkCommunicationFailure (4535), + cardClockFailure (4536), + powerModuleFailure (4537), + recurringLicenseExpired (4538), + transmitDegradeAdd (4539), + transmitDegradeDrop (4540), + transmitFailAdd (4541), + transmitFailDrop (4542), + poolAddressError (4543), + recoverMode (4544), + channelLicenseNotAvailable (4545), + pumpsManuallyDisabled (4546), + neConfigurationBackupFailed (4547), + compactFlashFailure0 (4548), + compactFlashFailure1 (4549), + compactFlashInsufficientSize0 (4550), + compactFlashInsufficientSize1 (4551), + fileSynchronizationFail (4552), + linkManuallyShutDown (4553), + bitRateError (4554), + backPlaneLossOfSignal (4555), + cpaMismatch (4556), + backPlaneLossOfSignal1 (4557), + backPlaneLossOfSignal2 (4558), + backPlaneLossOfSignal3 (4559), + backPlaneLossOfSignal4 (4560), + thresholdBbe15IngressNearEnd (4800), + thresholdBbe15IngressFarEnd (4801), + thresholdBbe15EgressNearEnd (4802), + thresholdBbe15EgressFarEnd (4803), + thresholdBbe24IngressNearEnd (4804), + thresholdBbe24IngressFarEnd (4805), + thresholdBbe24EgressNearEnd (4806), + thresholdBbe24EgressFarEnd (4807), + thresholdEs15IngressNearEnd (4808), + thresholdEs15IngressFarEnd (4809), + thresholdEs15EgressNearEnd (4810), + thresholdEs15EgressFarEnd (4811), + thresholdEs24IngressNearEnd (4812), + thresholdEs24IngressFarEnd (4813), + thresholdEs24EgressNearEnd (4814), + thresholdEs24EgressFarEnd (4815), + thresholdSes15IngressNearEnd (4816), + thresholdSes15IngressFarEnd (4817), + thresholdSes15EgressNearEnd (4818), + thresholdSes15EgressFarEnd (4819), + thresholdSes24IngressNearEnd (4820), + thresholdSes24IngressFarEnd (4821), + thresholdSes24EgressNearEnd (4822), + thresholdSes24EgressFarEnd (4823), + thresholdUas15IngressNearEnd (4824), + thresholdUas15IngressFarEnd (4825), + thresholdUas15EgressNearEnd (4826), + thresholdUas15EgressFarEnd (4827), + thresholdUas24IngressNearEnd (4828), + thresholdUas24IngressFarEnd (4829), + thresholdUas24EgressNearEnd (4830), + thresholdUas24EgressFarEnd (4831), + sflcf (4832), + mibFileMismatch (4833), + lossOfStationTimingInput (4834), + bdiEgress (4835), + signalDegradedEgress (4836), + lockedDefectEgress (4837), + openConnectionIndicationEgress (4838), + lossOfTandemConnectionEgress (4839), + failureOfProtocolProvisioningMismatchEgress (4840), + failureOfProtocolNoResponseEgress (4841), + alarmIndicationSig (4842), + ethLossOfPointer (4843), + pathLabelMismatch (4844), + lossOfCodeGroupDelineation (4845), + sc1plus1SyncFailure (4846), + debugInterfaceActive (4847), + ceLAGInterfaceFailureNotif (5510), + ceLAGInterfacePROTNANotif (5511), + ceMACLOSNotif (5512), + ceMACLOSYNCNotif (5513), + ceMACTRDIENotif (5514), + ceMACANFNotif (5515), + ceMACSFNotif (5516), + ceMACSDNotif (5517), + ceMACPortLinkFlappingNotif (5518), + ceMACPortDyingGaspNotif (5519), + ceMSTGlobalErrTrap (5520), + ceMSTUnExpMSTPPDUReceivedTrap (5521), + ceRSTGlobalErrTrap (5522), + ceMIEcfmdot1agRDICCMNotif (5523), + ceMIEcfmdot1agMACstatusNotif (5524), + ceMIEcfmdot1agRemoteMepCCMNotif (5525), + ceMIEcfmdot1agErrorCCMNotif (5526), + ceMIEcfmdot1agXconCCMNotif (5527), + ceMIEcfmY1731AISNotif (5528), + ceEqFreeRunningSyncModeNotif (5529), + ceEqHoldOverSyncModeNotif (5530), + ceEqMEANotif (5531), + ceEqMEAHWVMNotif (5532), + ceEqPROTNANotif (5533), + ceEqPowerFeedANotif (5534), + ceEqPowerFeedBNotif (5535), + ceEqReplUnitMissingNotif (5536), + ceEqReplUnitDegradeNotif (5537), + ceEqReplUnitFailedNotif (5538), + ceEqSWDownLoadFailureNotif (5539), + ceEqThermalNotif (5540), + ceEnvNotif (5541), + ceSntpPrimarySNTPServerUnreachable (5542), + ceSntpSecondarySNTPServerUnreachable (5543), + ceElpsProtectionTypeMismatchNotif (5544), + ceElpsConfigurationMismatchNotif (5545), + ceElpsLackOfResponseNotif (5546), + ceElpsProtectionNotAvailableNotif (5547), + ceElpsProtectionGroupFailedNotif (5548), + ceElpsFailureOfProtocolNotif (5549), + ceSyncERefFailureNotif (5550), + ceErpsProvisioningMismatchNotif (5551), + ceErpsFailureOfProtectionNotif (5552), + ceErpsAPSMNotReceivedNotif (5553), + ceErpsProtectedVlanFailureNotif (5554), + ceErpsRingProtectionNotAvailNotif (5555), + ceErpsVlanProtectionNotAvailNotif (5556), + ceExtStatusNotif (5557), + conv2Synth (6000), + agc (6001), + acgPrealarm (6002), + ais10Inserted (6003), + ais11Inserted (6004), + ais12Inserted (6005), + ais13Inserted (6006), + ais14Inserted (6007), + ais15Inserted (6008), + ais16Inserted (6009), + ais1Inserted (6010), + ais2Inserted (6011), + ais3Inserted (6012), + ais4Inserted (6013), + ais5Inserted (6014), + ais6Inserted (6015), + ais7Inserted (6016), + ais8Inserted (6017), + ais9Inserted (6018), + aisInsertedOnAllTribs (6019), + aisInsertedUserSide (6020), + alignBankStatus (6021), + allChannelsInService (6022), + atpc (6023), + b0AlarmDem (6024), + b0AlarmInterfaceUnit (6025), + b0AlarmTrib1 (6026), + b0AlarmTrib2 (6027), + b0AlarmTrib3 (6028), + b0AlarmTrib4 (6029), + b1SD (6030), + b2SD (6031), + backplaneEepromFailure (6032), + bypassCardFailure (6033), + ch1 (6034), + ch2 (6035), + channelForced (6036), + channelForcedViaExtSwitch (6037), + channelOnStandby (6038), + ckSyncDem (6039), + ckSyncInterfaceUnit (6040), + ckSyncModule (6041), + ckSyncTrib1 (6042), + ckSyncTrib2 (6043), + ckSyncTrib3 (6044), + ckSyncTrib4 (6045), + ckSyncTribOcc (6046), + coChannelXpic (6047), + cpuAlarm (6048), + dChannelDropLossOfAlignment (6049), + dChannelInsertionLossOfAlignment (6050), + dataExpCableFault (6051), + dataExpCableMissing (6052), + dem1SyncSourceOn (6053), + dem2SyncSourceOn (6054), + demCardFailure (6055), + demStandbyOccSyncSourceOn (6056), + demSideFail (6057), + demSwitch (6058), + demSyncLos (6059), + demSyncOn (6060), + demSyncSourceOn (6061), + divCardFailure (6062), + downloadStatus (6063), + dataTransitionMissingDccm (6064), + dataTransitionMissingF1 (6065), + dataTransitionMissingK11 (6066), + dataTransitionMissingK12 (6067), + dataTransitionMissingK4 (6068), + dataTransitionMissingK7 (6069), + eepromFailure2 (6070), + ew (6072), + externalAlarmInput (6073), + externalSyncSource1On (6074), + externalSyncSource2On (6075), + externalSyncSourceEnabled (6076), + externalSyncSourceNotPresent (6077), + f1Los (6078), + fanAlarm (6079), + fan1Alarm (6080), + fan2Alarm (6081), + fan1Unit (6082), + fan2Unit (6083), + farEndBlockError (6084), + farEndRemoteFailure (6085), + frequencyPlan16ComplianceTestAlarm (6086), + frequencyPlan2ComplianceTestAlarm (6087), + frequencyPlan4ComplianceTestAlarm (6088), + frequencyPlan8ComplianceTestAlarm (6089), + hber (6090), + heaterFail1 (6091), + heaterFail2 (6092), + highEarlyWarning (6093), + highFastBer (6094), + hitlessSwitchLossOfAlignment (6095), + hopTraceIdMismatch (6096), + inputDataDem (6097), + inputDataTrib1 (6098), + inputDataTrib2 (6099), + inputDataTrib3 (6100), + inputDataTribOcc (6101), + iduBoardDemodParityAlarm (6102), + iduBoardLaserTxFail (6103), + iduBoardModulatorFpgaKo (6104), + iduBoardModulatorParityAlarm (6105), + iduBoardMtiSdhLocal (6106), + iduBoardMtiSdhRx (6107), + iduBoardOpticalTxRxAgeing (6108), + iduBoardSdhTribRxPllLock (6109), + iduBoardSdhTribTxPllLock (6110), + iduHardwareMismatch (6111), + iduOduIfFskLof (6112), + interfaceFailure (6113), + iduOduIfCable (6114), + iduOduIfLosRx (6115), + iduSoftwareMismatch (6116), + ifBoard (6117), + ifDemAlarm (6118), + incomingAis2 (6119), + internalCardFailure (6120), + k5LosSide1 (6121), + k5LosSide2 (6122), + k5LosSide3 (6123), + k5LosSide4 (6124), + k5LosSide5 (6125), + k5LosSide6 (6126), + k5LosSide7 (6127), + k6LosSide1 (6128), + k6LosSide2 (6129), + k6LosSide3 (6130), + k6LosSide4 (6131), + k6LosSide5 (6132), + k6LosSide6 (6133), + k6LosSide7 (6134), + k7LosSide2 (6135), + k7LosSide3 (6136), + k7LosSide4 (6137), + k7LosSide5 (6138), + k7LosSide6 (6139), + k7LosSide7 (6140), + k7LosSide8 (6141), + k7LosSideStdby (6142), + k8LosSide2 (6143), + k8LosSide3 (6144), + k8LosSide4 (6145), + k8LosSide5 (6146), + k8LosSide6 (6147), + k8LosSide7 (6148), + k8LosSide8 (6149), + k8LosSideStdby (6150), + line1Dccm (6151), + line1Dccr (6152), + line1EDccr (6153), + line1RxClockLos (6154), + line1TxClockLos (6155), + line1WDccr (6156), + line2Dccm (6157), + line2Dccr (6158), + line2EDccr (6159), + line2RxClockLos (6160), + line2TxClockLos (6161), + line2WDccr (6162), + laser (6163), + laserStatus (6164), + lowEarlyWarning (6165), + lowFastBer (6166), + linkIdentificationCodeError (6167), + localOscill (6168), + lofRfcoh (6169), + lofTrib (6170), + losK21 (6171), + losK22 (6172), + losK5 (6173), + losK6 (6174), + losK7 (6175), + losK8 (6176), + mainMasterOscSyncLos (6177), + mainTribSyncLos (6178), + manualOperation (6179), + mainBattery (6180), + modulatorAlarm (6181), + modemBoard (6182), + modSideFail (6183), + modSyncOn (6184), + masterOscSyncLos (6185), + masterOscSyncOn (6186), + msAis (6187), + msRdi (6188), + oduHardwareMismatch (6189), + oduLine1RxClockLos (6190), + oduLine1TxClockLos (6191), + oduLine2TxClockLos (6192), + oduLine2RxClockLos (6193), + oduSwitch (6194), + oduSwitchMismatch (6195), + ohBusRxFailureSideA (6196), + ohBusRxFailureSideB (6197), + ohBusRxFailureSide1 (6198), + ohBusRxFailureSide2 (6199), + ohBusRxFailureSide3 (6200), + ohBusRxFailureSide4 (6201), + ohBusRxFailureSide5 (6202), + ohBusRxFailureSide6 (6203), + ohBusRxFailureSide7 (6204), + ohBusRxFailureSide8 (6205), + ohBusRxSideA (6206), + ohBusRxSideB12 (6207), + ohBusRxSideB13 (6208), + ohBusRxSideB (6209), + ohBusRxSideB24 (6210), + ohBusRxSideBStdby3 (6211), + ohBusRxSideStdby (6212), + ohBusTxFailSideA (6213), + ohBusTxFailSideB (6214), + ohBusTxFailSide1 (6215), + ohBusTxFailSide2 (6216), + ohBusTxFailSide3 (6217), + ohBusTxFailSide4 (6218), + ohBusTxFailSide5 (6219), + ohBusTxFailSide6 (6220), + ohBusTxFailSide7 (6221), + ohBusTxFailSide8 (6222), + ohBusTxSideA (6223), + ohBusTxSideB (6224), + ohBusTxSideB12 (6225), + ohBusTxSideB13 (6226), + ohBusTxSideB24 (6227), + ohBusTxSideBStdby3 (6228), + ohBusTxSideStdby (6229), + ohBusRxSide1 (6230), + ohBusRxSide2 (6231), + ohBusTxSide1 (6232), + ohBusTxSide2 (6233), + outputPower (6234), + phaseShifter (6235), + protectionBypassCardFailure (6236), + protMasterOscSync (6237), + protMasterOscSyncLos (6238), + protTribSyncLos (6239), + psu1 (6240), + psu2 (6241), + powerSupplyFailure2 (6242), + psFilterAndDistributorPreAlarm (6243), + qInterfaceFault (6244), + ready (6245), + receiverFailure (6246), + refusedSwitchingChannel1 (6247), + refusedSwitchingChannel2 (6248), + refusedSwitchingChannel3 (6249), + refusedSwitchingChannel4 (6250), + refusedSwitchingChannel5 (6251), + refusedSwitchingChannel6 (6252), + refusedSwitchingChannel7 (6253), + remoteLoopBackActivation (6254), + rfDiversity (6255), + rfLos (6256), + rfMain (6257), + rfSwitchAlarm (6258), + rpsLocked (6259), + rsTim (6260), + routingTableDccConfMismatchBank1 (6261), + routingTableDccConfMismatchBank2 (6262), + routingTableIntegrityFailureBank1 (6263), + routingTableIntegrityFailureBank2 (6264), + rtmUnitForced (6265), + routingTableNsapMismatchBank1 (6266), + routingTableNsapMismatchBank2 (6267), + rx1ewPowerSupply (6268), + rx1wePowerSupply (6269), + rx2ewPowerSupply (6270), + rx2wePowerSupply (6271), + rx3ewPowerSupply (6272), + rx3wePowerSupply (6273), + rx4ewPowerSupply (6274), + rx4wePowerSupply (6275), + rx5ewPowerSupply (6276), + rx5wePowerSupply (6277), + rx6ewPowerSupply (6278), + rx6wePowerSupply (6279), + rx7ewPowerSupply (6280), + rx7wePowerSupply (6281), + rx8ewPowerSupply (6282), + rx8wePowerSupply (6283), + rxAisInserted (6284), + rxAlignment (6285), + rxAuAis1 (6286), + rxAuAis2 (6287), + rxAuAisP (6288), + rxAuAisW (6289), + rxAuLop1 (6290), + rxAuLop2 (6291), + rxAuLopP (6292), + rxAuLopW (6293), + rxB1SD (6294), + rxSideCardFailure (6295), + rxCodeSide1 (6296), + rxCodeSide2 (6297), + rxCodeSideA (6298), + rxCodeSideB (6299), + rxCodeSideStdby (6300), + rxDem1PowerSupply (6301), + rxDem2PowerSupply (6302), + rxDem3PowerSupply (6303), + rxDem4PowerSupply (6304), + rxDem5PowerSupply (6305), + rxDem6PowerSupply (6306), + rxDem7PowerSupply (6307), + rxDem8PowerSupply (6308), + rxDemStdbyPowerSupply (6309), + rxInput1 (6310), + rxInput2 (6311), + rxInputP (6312), + rxInputW (6313), + exLof (6314), + rxManualOperation (6315), + rxMgc (6316), + rxOduFailure (6317), + rxOnLineChannelFailure (6318), + rxOscillator (6319), + rxPowerFailure (6320), + rxSynthFailure (6321), + scs1 (6322), + scs2 (6323), + selectedDataInput (6324), + selfTestFail (6325), + selectedInput (6326), + sharedData (6327), + side1 (6328), + side1Sd (6329), + side2 (6330), + side2Sd (6331), + sideA (6332), + sideA12 (6333), + sideA12Sd (6334), + sideA13 (6335), + sideA13Sd (6336), + sideASd (6337), + sideB (6338), + sideB12 (6339), + sideB24 (6340), + sideB3 (6341), + sideBsd (6342), + stm1B1SdExp (6343), + stm1B1SdMain (6344), + stm1FailExp (6345), + stm1FailMain (6346), + swIntegrityFailureBank1 (6347), + swIntegrityFailureBank2 (6348), + switchingAlarmChannel1 (6349), + switchingAlarmChannel2 (6350), + switchingAlarmChannel3 (6351), + switchingAlarmChannel4 (6352), + switchingAlarmChannel5 (6353), + switchingAlarmChannel6 (6354), + switchingAlarmChannel7 (6355), + switchHsbyFailure (6356), + switchingTestFailureStdbyChannel1 (6357), + switchingTestFailureStdbyChannel2 (6358), + switchingTestFailureStdbyChannel3 (6359), + switchingTestFailureStdbyChannel4 (6360), + switchingTestFailureStdbyChannel5 (6361), + switchingTestFailureStdbyChannel6 (6362), + switchingTestFailureStdbyChannel7 (6363), + switchingTestFailureStdby (6364), + syncFailureMain (6365), + syncOn (6366), + synthetizer (6367), + systemBackupKey (6368), + systemBackupKeyNotInserted (6369), + systemForced1Plus0MasterConfig (6370), + systemSwitchesFrozen (6371), + timRf (6372), + timTributary (6373), + tributary10Hdb3ViolationDetection (6374), + tributary10InputFailure (6375), + tributary10OutputFailure (6376), + tributary11Hdb3ViolationDetection (6377), + tributary11InputFailure (6378), + tributary11OutputFailure (6379), + tributary12Hdb3ViolationDetection (6380), + tributary12InputFailure (6381), + tributary12OutputFailure (6382), + tributary13Hdb3ViolationDetection (6383), + tributary13InputFailure (6384), + tributary13OutputFailure (6385), + tributary14Hdb3ViolationDetection (6386), + tributary14InputFailure (6387), + tributary14OutputFailure (6388), + tributary15Hdb3ViolationDetection (6389), + tributary15InputFailure (6390), + tributary15OutputFailure (6391), + tributary16Hdb3ViolationDetection (6392), + tributary16InputFailure (6393), + tributary16OutputFailure (6394), + tributary1Dccr (6395), + tributary1Hdb3ViolationDetection (6396), + tributary1InputFailure (6397), + tributary1OutputFailure (6398), + tributary1SyncSourceOn (6399), + tributary2Dccr (6400), + tributary2Hdb3ViolationDetection (6401), + tributary2InputFailure (6402), + tributary2OutputFailure (6403), + tributary2SyncSourceOn (6404), + tributary3Dccr (6405), + tributary3Hdb3ViolationDetection (6406), + tributary3InputFailure (6407), + tributary3OutputFailure (6408), + tributary3SyncSourceOn (6409), + tributary4SyncSourceOn (6410), + tributary4Dccr (6411), + tributary4Hdb3ViolationDetection (6412), + tributary4InputFailure (6413), + tributary4OutputFailure (6414), + tributary5Hdb3ViolationDetection (6415), + tributary5InputFailure (6416), + tributary5OutputFailure (6417), + tributary6Hdb3ViolationDetection (6418), + tributary6InputFailure (6419), + tributary6OutputFailure (6420), + tributary7Hdb3ViolationDetection (6421), + tributary7InputFailure (6422), + tributary7OutputFailure (6423), + tributary8Hdb3ViolationDetection (6424), + tributary8InputFailure (6425), + tributary8OutputFailure (6426), + tributary9Hdb3ViolationDetection (6427), + tributary9InputFailure (6428), + tributary9OutputFailure (6429), + tributaryADccr (6430), + tributaryAisInserted (6431), + tributaryBDccr (6432), + tributaryCDccr (6433), + tributaryConfiguration (6434), + tributaryDccm (6435), + tributaryDccr (6436), + tributaryDDccr (6437), + tributaryOccDccr (6438), + tributaryOccSyncSourceOn (6439), + tributarySwitch (6440), + tributarySyncLos (6441), + tributarySyncSourceOn (6442), + tx1ewPowerSupply (6443), + tx1PowerSupply (6444), + tx1wePowerSupply (6445), + tx2ewPowerSupply (6446), + tx2PowerSupply (6447), + tx2wePowerSupply (6448), + tx3ewPowerSupply (6449), + tx3PowerSupply (6450), + tx3wePowerSupply (6451), + tx4ewPowerSupply (6452), + tx4PowerSupply (6453), + tx4wePowerSupply (6454), + tx5ewPowerSupply (6455), + tx5PowerSupply (6456), + tx5wePowerSupply (6457), + tx6ewPowerSupply (6458), + tx6PowerSupply (6459), + tx6wePowerSupply (6460), + tx7ewPowerSupply (6461), + tx7PowerSupply (6462), + tx7wePowerSupply (6463), + tx8ewPowerSupply (6464), + tx8PowerSupply (6465), + tx8wePowerSupply (6466), + txAmplifier (6467), + txAuAis (6468), + txAuLop (6469), + txB1Sd (6470), + txB2Eber (6471), + txB2Sd (6472), + txSideCardFailure (6473), + txCkSync1 (6474), + txCkSync2 (6475), + txCkSyncP (6476), + txCkSyncW (6477), + txIfLos (6478), + txLos (6479), + txManualOperation (6480), + txMsAis (6481), + txMsRdi (6482), + txOduFailure (6483), + txOnLineChannelFailure (6484), + txOscillator (6485), + txPowerWrong (6486), + txSquelchOn (6487), + txSynth (6488), + txStdbyPowerSupply (6489), + unitFailure (6490), + userChBoard (6491), + vcoFrequencyDeviation (6492), + wsAisInserted (6493), + wsChBoard (6494), + wsLos (6495), + xpicFail (6496), + xpicIfInput (6497), + aisReceived (6498), + consecutiveSesProtection (6499), + dccFailure (6500), + demBlockFailure (6501), + eberB2 (6502), + eberRp (6503), + es15Min (6504), + es24h (6505), + fading (6506), + fanFailureR (6507), + ferFailure (6508), + frameAlignmentLoss (6509), + holdoverStateEntered (6510), + hopFerFailure (6511), + hopUnequipped (6512), + internalClockStateEntered (6513), + laserBiasOutOfLimits (6514), + logMemoryThresholdCrossed (6515), + lossOfClockSignal6Mhz (6516), + los2Mbps (6517), + los2Mhz (6518), + losInDem (6519), + losInMod (6520), + losInRx (6521), + losInSTM (6522), + losInTx (6523), + losInXpic (6524), + lossOfProtectionSignal (6525), + mainRxReceivedLevelDown (6526), + modBlockFailure (6527), + mspArchitectureMatchFailure (6528), + mspChannelMatchFailure (6529), + mspCpu1Failure (6530), + mspCpu2Failure (6531), + mspCpu3Failure (6532), + mspCpu4Failure (6533), + mspDirectionMatchFailure (6534), + networkReferenceClockQualityDown (6535), + opticalTransmitPowerOutOfRange (6536), + opticalTransmitPowerDegraded (6537), + pathTraceIdMismatch (6538), + priorityChannelMismatch (6539), + psFailure (6540), + radioRouteIdMismatch (6541), + remoteAlarmIndication (6542), + rxBlockFailure (6543), + signalDegradeB2 (6544), + sdRxReceivedLevelDown (6545), + sectionTraceIdMismatch (6546), + serialInterfaceFailure (6547), + ses15Min (6548), + ses24h (6549), + signalLabelMismatch (6550), + svBackupSubunitFailure (6551), + switchFailureInBsw (6552), + switchFailureInUsw (6553), + swVersionMismatch2 (6554), + transactionLogMemoryThresholdCrossed (6555), + txBlockFailure (6556), + unavailableStateB1 (6557), + unavailableStateB2 (6558), + unavailableStateB3 (6559), + unavailableStateFebe (6560), + unavailableStateRp (6561), + swDownloadFailure (6562), + freqPlanFail (6563), + badConfigSlaveUnits (6564), + swNotAligned (6565), + systemBackupKeyNotAligned (6566), + psu3 (6567), + psu4 (6568), + bb1Bb2DataInterfaceFailure (6569), + uPAlarm (6570), + stationAlarm1 (6571), + stationAlarm2 (6572), + stationAlarm3 (6573), + stationAlarm4 (6574), + stationAlarm5 (6575), + stationAlarm6 (6576), + stationAlarm7 (6577), + stationAlarm8 (6578), + stationAlarm9 (6579), + stationAlarm10 (6580), + stationAlarm11 (6581), + stationAlarm12 (6582), + stationAlarm13 (6583), + stationAlarm14 (6584), + stationAlarm15 (6585), + stationAlarm16 (6586), + stationAlarm17 (6587), + stationAlarm18 (6588), + stationAlarm19 (6589), + stationAlarm20 (6590), + stationAlarm21 (6591), + stationAlarm22 (6592), + stationAlarm23 (6593), + stationAlarm24 (6594), + stationAlarm25 (6595), + stationAlarm26 (6596), + stationAlarm27 (6597), + stationAlarm28 (6598), + stationAlarm29 (6599), + stationAlarm30 (6600), + stationAlarm31 (6601), + stationAlarm32 (6602), + aisProtSide (6603), + berSdProtSide (6604), + signalDegradeHighProtSide (6605), + signalDegradeLowProtSide (6606), + xpicFailProtSide (6607), + ber10Em3ProtSide (6608), + demBlockFailureProtSide (6609), + hberProtSide (6610), + rxODUFailureProtSide (6611), + freqPlanFailProtSide (6612), + freqPlan16ComplTestAlarmProtSide (6613), + freqPlan2ComplTestAlarmProtSide (6614), + freqPlan4ComplTestAlarmProtSide (6615), + freqPlan8ComplTestAlarmProtSide (6616), + inputSignalDisabledTribProtSide (6617), + txOnLineChanFailProtSide (6618), + lofProtSide (6619), + txLOSProtSide (6620), + losInXPICProtSide (6621), + coChannelXPICProtSide (6622), + farEndBlockErrorProtSide (6623), + farEndRemoteFailureProtSide (6624), + rdiProtSide (6625), + ssfProtSide (6626), + radioRouteIdMismatchProtSide (6627), + atpcFailureProtSide (6628), + agcFailureProtSide (6629), + modBlockFailureProtSide (6630), + txFailProtSide (6631), + systemInitInProgress (6632), + ethernetPortDown (6633), + accPortLinkLayerDown (6634), + accPortLoopDetected (6635), + accPortPhysLayerDown (6636), + circuitDown (6637), + circuitIntrusiveTest (6638), + circuitUnprotected (6639), + lapdDown (6640), + manReversionRequired (6641), + pathSelectorMismatch (6642), + primaryPathDown (6643), + reversionFailed (6644), + busDown (6645), + cardTypeMisMatch (6646), + optRoutingParamNok (6647), + trunkDown (6648), + virtualTrunkDegradation (6649), + virtualTrunkDown (6650), + virtualTrunkSessionDown (6651), + allFansHaveFailed (6652), + fanFailed (6653), + fanLossOfRedundancy (6654), + fanRemoved (6655), + mspAutoSwitchSd (6656), + mspAutoSwitchSdFar (6657), + mspAutoSwitchSf (6658), + mspAutoSwitchSfFar (6659), + mspChannelMismatch (6660), + mspFarEndProtectFail (6661), + mspForcedSwiToProt (6662), + mspForcedSwiToProtFar (6663), + mspForcedSwiToWork (6664), + mspForcedSwiToWorkFar (6665), + mspLockoutProtection (6666), + mspLockoutProtectionFar (6667), + mspManualSwitchProt (6668), + mspManualSwitchProtFar (6669), + mspModeMismatch (6670), + mspProtSwitchByteFail (6671), + mspProtSwitchDenial (6672), + mspSwitchToProtDnr (6673), + mspSwitchToProtDnrFar (6674), + mspSwitchToProtWtr (6675), + mspSwitchToProtWtrFar (6676), + auditTrailLogFullThreshold (6677), + autoLaserShutdown (6678), + checksumConfigFileNok (6679), + badConfigFile (6680), + cardHwMaintenance (6681), + configFileNotFound (6682), + configNotApproved (6683), + defaultKBytes (6684), + eastExtraTrafficPreemp (6685), + eepromFailure (6686), + errorReadingIdprom (6687), + errorReadingCleiCode (6688), + errorReadingFanIdprom (6689), + fileSystemAlmostFull (6690), + forceSwitchRingEastK1 (6691), + forceSwitchRingWestK1 (6692), + forceSwitchRingEast (6693), + forceSwitchRingWest (6694), + forceSwitchSpanEastK1 (6695), + forceSwitchSpanWestK1 (6696), + forceSwitchSpanEast (6697), + forceSwitchSpanWest (6698), + foreignConfig (6699), + hardwareFailure (6700), + improperApsCodes (6701), + invalidCard (6702), + invalidProductCodeOrRev (6703), + invalidShelf (6704), + lapdConfigMismatch (6705), + laserBiasCurrentHigh (6706), + laserDisabled (6707), + laserFailure (6708), + laserPowerOutOfLock (6709), + laserShutdown (6710), + laserTempOutOfRange (6711), + laserWaveOutOfLock (6712), + lockoutEastWorkRing (6713), + lockoutEastWorkSpan (6714), + lockoutProtAllSpans (6715), + lockoutProtEast (6716), + lockoutProtFromEastK1 (6717), + lockoutProtFromWestK1 (6718), + lockoutProtWest (6719), + lockoutWestWorkRing (6720), + lockoutWestWorkSpan (6721), + logWriteFail (6722), + manSwitchRingEastK1 (6723), + manSwitchRingWestK1 (6724), + manSwitchRingEast (6725), + manSwitchRingWest (6726), + manSwitchSpanEastK1 (6727), + manSwitchSpanWestK1 (6728), + manSwitchSpanEast (6729), + manSwitchSpanWest (6730), + modulatorOutOfLock (6731), + noConfigFileLoaded (6732), + nodeIdMismatch (6733), + pathProtSelectorAlarm (6734), + portInLoopbackMode (6735), + receivePowerOutOfRange (6736), + redundantPairCommFail (6737), + shelfDcFilterFailure (6738), + softwareDownloadFailed (6739), + softwareUnpackFailed (6740), + squelchEastWorkTraffic (6741), + squelchWestWorkTraffic (6742), + swVersionMismatch (6743), + transmitPowerOutRange (6744), + voaFailure (6745), + wavelengthItuMismatch (6746), + westExtraTrafficPreemp (6747), + circuitXcLoopback (6748), + autoSwitchRingSDEastK1 (6749), + autoSwitchRingSDWestK1 (6750), + autoSwitchRingSFEastK1 (6751), + autoSwitchRingSFWestK1 (6752), + autoSwitchRingSDEast (6753), + autoSwitchRingSFEast (6754), + autoSwitchRingSDWest (6755), + autoSwitchRingSFWest (6756), + autoSwitchSpanSDEastK1 (6757), + autoSwitchSpanSDWestK1 (6758), + autoSwitchSpanSFEastK1 (6759), + autoSwitchSpanSFWestK1 (6760), + autoSwitchSpanSDEast (6761), + autoSwitchSpanSFEast (6762), + autoSwitchSpanSDWest (6763), + autoSwitchSpanSFWest (6764), + autoSquelchNoMatchID (6765), + invalidPortConfiguration (6766), + protPassThroughXcUnres (6767), + switchExerciseRingFailed (6768), + switchExerciseSpanFailed (6769), + waitToRestore (6770), + serverNotReachable (6771), + serverNotInSynch (6772), + forcedSwitchOverInEffect (6773), + forcedSwitchOverFailed (6774), + powerSupplyFailure (6775), + cardMissing2 (6776), + shelfDcFilterRemoved (6777), + configDownload (6778), + softwareDownloading (6779), + backplaneInternalLinkFault (6780), + lossOfTimingSource (6781), + bitsPll0OutOfLock (6782), + bitsPll1OutOfLock (6783), + insuffLockTimeForHoStab (6784), + monitorPortAInputRefBad (6785), + monitorPortBInputRefBad (6786), + port1BothTimingLinkDown (6787), + port1TimingLinkDown (6788), + port2BothTimingLinkDown (6789), + port2TimingLinkDown (6790), + port3BothTimingLinkDown (6791), + port3TimingLinkDown (6792), + port4BothTimingLinkDown (6793), + port4TimingLinkDown (6794), + port5BothTimingLinkDown (6795), + port5TimingLinkDown (6796), + timingClockNotEnabled (6797), + timingControllerFreeRun (6798), + timingControllerHoldover (6799), + timingModuleLossOfLock (6800), + tuningVoltageLevelClock (6801), + cardTimingSubsysFault (6802), + bothPrimSecTrcOutService (6803), + bothReferencesBad (6804), + aisInBitsPrimaryReference (6805), + losInBitsPrimaryReference (6806), + lossOfHigherBitsTimeSrc (6807), + noClockEdgeInBitsPrimRef (6808), + aisInBitsSecondaryRef (6809), + losInBitsSecondaryRef (6810), + lossOfLowerBitsTimingSrc (6811), + noClockEdgeInBitsSecRef (6812), + intrusiveTestAccess (6813), + thresholdHighestBbe15 (6814), + thresholdHighestBbe15FarEnd (6815), + thresholdHighestBbe24 (6816), + thresholdHighestBbe24FarEnd (6817), + thresholdHighestEs15 (6818), + thresholdHighestEs15FarEnd (6819), + thresholdHighestEs24 (6820), + thresholdHighestEs24FarEnd (6821), + thresholdHighestSes15 (6822), + thresholdHighestSes15FarEnd (6823), + thresholdHighestSes24 (6824), + thresholdHighestSes24FarEnd (6825), + thresholdHighestUas15 (6826), + thresholdHighestUas15FarEnd (6827), + thresholdHighestUas24 (6828), + thresholdHighestUas24FarEnd (6829), + thresholdHighestCv15 (6830), + thresholdHighestCv15FarEnd (6831), + thresholdHighestCv24 (6832), + thresholdHighestCv24FarEnd (6833), + thresholdHighestSefs15 (6834), + thresholdHighestSefs15FarEnd (6835), + thresholdHighestSefs24 (6836), + thresholdHighestSefs24FarEnd (6837), + radioDataTransMissA (6838), + radioDTMTrib1 (6839), + radioDTMTrib2 (6840), + radioHPSyncLoss (6841), + radioLOFHWP (6842), + radioSyncFromModT1 (6843), + radioSyncFromModT2 (6844), + radioSyncFromMod12 (6845), + radioCKSyncDem1 (6846), + radioCKSyncDem2 (6847), + radioMod1PSfail (6848), + radioMod2PSfail (6849), + radioModSyncLoss (6850), + radioAGCPREALMHSBY (6851), + radioPSHstbyFail (6852), + radioEOWRC1 (6853), + radioEOWRC2 (6854), + radioRXSection (6855), + radioTrib1ConfAlm (6856), + radioTrib2ConfAlm (6857), + radioTrib3ConfAlm (6858), + radioTrib4ConfAlm (6859), + radioTrib5ConfAlm (6860), + radioTrib6ConfAlm (6861), + radioTrib7ConfAlm (6862), + radioTrib8ConfAlm (6863), + radioTrib9ConfAlm (6864), + radioTrib10ConfAlm (6865), + radioTrib11ConfAlm (6866), + radioTrib12ConfAlm (6867), + radioTrib13ConfAlm (6868), + radioTrib14ConfAlm (6869), + radioTrib15ConfAlm (6870), + radioTrib16ConfAlm (6871), + radioTrib1LOS (6872), + radioTrib2LOS (6873), + radioTrib3LOS (6874), + radioTrib4LOS (6875), + radioTrib5LOS (6876), + radioTrib6LOS (6877), + radioTrib7LOS (6878), + radioTrib8LOS (6879), + radioTrib9LOS (6880), + radioTrib10LOS (6881), + radioTrib11LOS (6882), + radioTrib12LOS (6883), + radioTrib13LOS (6884), + radioTrib14LOS (6885), + radioTrib15LOS (6886), + radioTrib16LOS (6887), + radioTrib1AISIN (6888), + radioTrib2AISIN (6889), + radioTrib3AISIN (6890), + radioTrib4AISIN (6891), + radioTrib5AISIN (6892), + radioTrib6AISIN (6893), + radioTrib7AISIN (6894), + radioTrib8AISIN (6895), + radioTrib9AISIN (6896), + radioTrib10AISIN (6897), + radioTrib11AISIN (6898), + radioTrib12AISIN (6899), + radioTrib13AISIN (6900), + radioTrib14AISIN (6901), + radioTrib15AISIN (6902), + radioTrib16AISIN (6903), + radioTrib1Code (6904), + radioTrib2Code (6905), + radioTrib3Code (6906), + radioTrib4Code (6907), + radioTrib5Code (6908), + radioTrib6Code (6909), + radioTrib7Code (6910), + radioTrib8Code (6911), + radioTrib9Code (6912), + radioTrib10Code (6913), + radioTrib11Code (6914), + radioTrib12Code (6915), + radioTrib13Code (6916), + radioTrib14Code (6917), + radioTrib15Code (6918), + radioTrib16Code (6919), + radioTrib1ConfAlmHWP (6920), + radioTrib2ConfAlmHWP (6921), + radioTrib3ConfAlmHWP (6922), + radioTrib4ConfAlmHWP (6923), + radioTrib5ConfAlmHWP (6924), + radioTrib6ConfAlmHWP (6925), + radioTrib7ConfAlmHWP (6926), + radioTrib8ConfAlmHWP (6927), + radioTrib9ConfAlmHWP (6928), + radioTrib10ConfAlmHWP (6929), + radioTrib11ConfAlmHWP (6930), + radioTrib12ConfAlmHWP (6931), + radioTrib13ConfAlmHWP (6932), + radioTrib14ConfAlmHWP (6933), + radioTrib15ConfAlmHWP (6934), + radioTrib16ConfAlmHWP (6935), + radioTrib1LOSHWP (6936), + radioTrib2LOSHWP (6937), + radioTrib3LOSHWP (6938), + radioTrib4LOSHWP (6939), + radioTrib5LOSHWP (6940), + radioTrib6LOSHWP (6941), + radioTrib7LOSHWP (6942), + radioTrib8LOSHWP (6943), + radioTrib9LOSHWP (6944), + radioTrib10LOSHWP (6945), + radioTrib11LOSHWP (6946), + radioTrib12LOSHWP (6947), + radioTrib13LOSHWP (6948), + radioTrib14LOSHWP (6949), + radioTrib15LOSHWP (6950), + radioTrib16LOSHWP (6951), + radioTrib1AISINHWP (6952), + radioTrib2AISINHWP (6953), + radioTrib3AISINHWP (6954), + radioTrib4AISINHWP (6955), + radioTrib5AISINHWP (6956), + radioTrib6AISINHWP (6957), + radioTrib7AISINHWP (6958), + radioTrib8AISINHWP (6959), + radioTrib9AISINHWP (6960), + radioTrib10AISINHWP (6961), + radioTrib11AISINHWP (6962), + radioTrib12AISINHWP (6963), + radioTrib13AISINHWP (6964), + radioTrib14AISINHWP (6965), + radioTrib15AISINHWP (6966), + radioTrib16AISINHWP (6967), + radioTrib1CodeHWP (6968), + radioTrib2CodeHWP (6969), + radioTrib3CodeHWP (6970), + radioTrib4CodeHWP (6971), + radioTrib5CodeHWP (6972), + radioTrib6CodeHWP (6973), + radioTrib7CodeHWP (6974), + radioTrib8CodeHWP (6975), + radioTrib9CodeHWP (6976), + radioTrib10CodeHWP (6977), + radioTrib11CodeHWP (6978), + radioTrib12CodeHWP (6979), + radioTrib13CodeHWP (6980), + radioTrib14CodeHWP (6981), + radioTrib15CodeHWP (6982), + radioTrib16CodeHWP (6983), + radioFif (6984), + radioRCh (6985), + radioR1Ch (6986), + radioR2Ch (6987), + radioD1Ch (6988), + radioD2Ch (6989), + radioLOPHWP (6990), + radioG703Los (6991), + pam (7200), + scm (7201), + otm (7202), + radioAISRXBHWP (7220), + radioAISTXHWP (7221), + radioB1BerHWP (7222), + radioB2BERSFHWP (7223), + radiobackupKeyMism (7224), + radioCCPairWrongCfg (7225), + radioCFP (7226), + radioCPUExpIf (7227), + radioDataTransMissB (7228), + radioDChanFail (7229), + radioDoubleKey (7230), + radioExpSyncSource (7231), + radioExtEOW (7232), + radioLaserDeg (7233), + radioLine1 (7234), + radioLine10 (7235), + radioLine11 (7236), + radioLine12 (7237), + radioLine13 (7238), + radioLine14 (7239), + radioLine15 (7240), + radioLine16 (7241), + radioLine17 (7242), + radioLine18 (7243), + radioLine19 (7244), + radioLine2 (7245), + radioLine20 (7246), + radioLine21 (7247), + radioLine3 (7248), + radioLine4 (7249), + radioLine5 (7250), + radioLine6 (7251), + radioLine7 (7252), + radioLine8 (7253), + radioLine9 (7254), + radioLOPBXHWP (7255), + radioLOPTXHWP (7256), + radioLOPWXHWP (7257), + radioLOSStby (7258), + radioLOSStby1 (7259), + radioLSIf (7260), + radioMemCk (7261), + radioMMOLos (7262), + radioModFail (7263), + radioPRPSLocked (7264), + radioPSProtectionLost (7265), + radioRFSearch (7266), + radioRSCLOF (7267), + radioRUCLOS (7268), + radioRxDistExtr (7269), + radioRxDistPS (7270), + radioSbusLink (7271), + radioStandbySwitchMismatch (7272), + radioTIMHWP (7273), + radioTunFail1 (7274), + radioTunFail10 (7275), + radioTunFail11 (7276), + radioTunFail12 (7277), + radioTunFail13 (7278), + radioTunFail14 (7279), + radioTunFail15 (7280), + radioTunFail16 (7281), + radioTunFail2 (7282), + radioTunFail3 (7283), + radioTunFail4 (7284), + radioTunFail5 (7285), + radioTunFail6 (7286), + radioTunFail7 (7287), + radioTunFail8 (7288), + radioTunFail9 (7289), + radioTxDistExtr (7290), + radioTxDistPS (7291), + radioInAisProt (7292), + radioOverTemp (7293), + radioXPICOff (7294), + radioStbyEEprom (7295), + radioB2BerProt (7296), + radioB2Ber3Prot (7297), + radioConfMism (7298), + radioMismFailAct (7299), + silvxBLSRLaserShutdown (7300), + silvxSectionTraceIdMismatch (7301), + silvxBLSRPeerCommDown (7302), + silvxTrcPullinCfgMismatch (7303), + silvxTrcPullinCapCfgMismatch (7304), + silvxLimHwConfigInvalid (7305), + silvxLimInvalid (7306), + silvxLimHardwareFailure (7307), + silvxLimEepromFailure (7308), + silvxLimFpgaFailure (7309), + silvxLimFpgaVersionMismatch (7310), + silvxLimTemp (7311), + silvxPortMismatch (7312), + silvxPortInvalid (7313), + silvxPortMissing (7314), + silvxPortEepromFailure (7315), + silvxPortHardwareFailure (7316), + silvxBridgeAndRollInProgress (7317), + silvxRollToPathDown (7318), + silvxEthernetServiceDown (7319), + silvxEthernetServiceDegraded (7320), + silvxCGDown (7321), + silvxCGDegraded (7322), + silvxCGDiffDelayExceeded (7323), + silvxCGSequenceError (7324), + silvxCGLossAlignment (7325), + silvxCGLossMultiframe (7326), + silvxPeerDiscLostContact (7327), + silvxPPGLockoutProtection (7328), + silvxPPGForceToWorking (7329), + silvxPPGForceToProtection (7330), + silvxPPGAutoSwitchToProtSF (7331), + silvxPPGAutoSwitchToProtWARM (7332), + silvxPPGAutoSwitchToProtSFBER (7333), + silvxPPGAutoSwitchToProtPDI (7334), + silvxPPGAutoSwitchToProtTIM (7335), + silvxPPGAutoSwitchToProtSD (7336), + silvxPPGMsToProt (7337), + silvxPPGAutoSwitchToProtWTR (7338), + silvxNoSystemTimingSrcProv (7339), + silvxTimingModuleStablizing (7340), + silvxEthernetServiceLocalCLF (7341), + silvxEthernetServiceRemoteCLF (7342), + silvxNetworkConnectionProblem (7343), + silvxMismatchedConfigRemoteCLF (7344), + silvxSoftwareActivation (7345), + silvxLIMSoftwareFailure (7346), + silvxLIMHwMaintenanceRequired (7347), + silvxLicenseInvalid (7348), + silvxLicenseExceeded (7349), + silvxLicenseExpired (7350), + silvxCleiLIMError (7351), + silvxCleiPortError (7352), + radioTXPLL19E (7353), + radioRXPLL6E (7354), + radioTXPLL6E (7355), + radioAISRXAHWP (7356), + radioAutGC (7357), + radioB2BerHWP (7358), + radioCErrTrib (7359), + radioEthIFault (7360), + radioBBExpCF (7361), + radioBBExpCM (7362), + radioBBExpIf (7363), + radioExtSync1 (7364), + radioExtSync2 (7365), + radioIDUHWMis (7366), + radioLine1DCCM (7367), + radioLine1DCCR (7368), + radioLine1EDCCR (7369), + radioLine1WDCCR (7370), + radioLine2DCCM (7371), + radioLine2DCCR (7372), + radioLine2EDCCR (7373), + radioLine2WDCCR (7374), + radioLOS8Cl (7375), + radioLOFGP1X (7376), + radioLOFGP1Y (7377), + radioLOFGP2X (7378), + radioLOFGP2Y (7379), + radioLOSUCh1 (7380), + radioLOSUCh2 (7381), + radioLOSSF (7382), + radioOHRXFail1 (7383), + radioOHRXFail2 (7384), + radioOHTXFail1 (7385), + radioOHTXFail2 (7386), + radioPChMGP1 (7387), + radioPChMGP2 (7388), + radioRTB1M (7389), + radioRTB2M (7390), + radioRTIB1 (7391), + radioRTIB2 (7392), + radioRTNSAPMB1 (7393), + radioRTNSAPMB2 (7394), + radioRXCardF (7395), + radioSCS1F (7396), + radioSCS2F (7397), + radioSelfTestF (7398), + radioSIFB1 (7399), + radioSIFB2 (7400), + radioSoftwM (7401), + radioSHSBYF (7402), + radioSTFStby (7403), + radioSTFStby1 (7404), + radioSTFStby2 (7405), + radioSTFStby3 (7406), + radioSLOSDem1 (7407), + radioSLOSDem2 (7408), + radioSLOSMod1 (7409), + radioSLOSMod2 (7410), + radioSLOSRXDem1 (7411), + radioSLOSRXDem2 (7412), + radioSLOSTXMod1 (7413), + radioTrib1DCCM (7414), + radioTX1PSF (7415), + radioTX2PSF (7416), + radioTXAmp (7417), + radioUPAl (7418), + radioVCOFreqDev (7419), + radioWCCCPair (7420), + silvxSysTimFreeRun (7421), + silvxSysTimLowSrc (7422), + silvxSysTimORef (7423), + silvxCardAdmDwn (7424), + silvxPortAdmDwn (7425), + silvxCardBoot (7426), + silvxCardPendRm (7427), + silvxSigIPPMFail (7428), + silvxPathAlFail (7429), + silvxTRCPMCProb (7430), + silvxCardTRCInit (7431), + silvxPathLbMism (7432), + silvxNodeLampTE (7433), + silvxShelfLampTE (7434), + silvxCardLampTE (7435), + silvxPortMiss (7436), + silvxCCRefMism (7437), + silvxRxFifoOverfl (7438), + radioAccessHWF (7439), + radioAISHWProt (7440), + radioAsicAl (7441), + radioE2promF (7442), + radioCableCF (7443), + radioCableCOutoRg (7444), + radioClStatSl6 (7445), + radioClStatSl7 (7446), + radioCodeErrTrib (7447), + radioDateLIdErr (7448), + radioDChanDroplos (7449), + radioDChanInslos (7450), + radioDeMapper (7451), + radioDEmbMismConf (7452), + radioE1LocOsc (7453), + radioE1T1P1Ais (7454), + radioE1T1P1Lcd (7455), + radioE1T1P1Lif (7456), + radioE1T1P1Lods (7457), + radioE1T1P1Lof (7458), + radioE1T1P1Los (7459), + radioE1T1P1Rfi (7460), + radioE1T1P2Ais (7461), + radioE1T1P2Lcd (7462), + radioE1T1P2Lif (7463), + radioE1T1P2Lods (7464), + radioE1T1P2Lof (7465), + radioE1T1P2Los (7466), + radioE1T1P2Rfi (7467), + radioE1T1P3Ais (7468), + radioE1T1P3Lcd (7469), + radioE1T1P3Lif (7470), + radioE1T1P3Lods (7471), + radioE1T1P3Lof (7472), + radioE1T1P3Los (7473), + radioE1T1P3Rfi (7474), + radioE1T1P4Ais (7475), + radioE1T1P4Lcd (7476), + radioE1T1P4Lif (7477), + radioE1T1P4Lods (7478), + radioE1T1P4Lof (7479), + radioE1T1P4Los (7480), + radioE1T1P4Rfi (7481), + radioE1T1P5Ais (7482), + radioE1T1P5Lcd (7483), + radioE1T1P5Lif (7484), + radioE1T1P5Lods (7485), + radioE1T1P5Lof (7486), + radioE1T1P5Los (7487), + radioE1T1P5Rfi (7488), + radioE1T1P6Ais (7489), + radioE1T1P6Lcd (7490), + radioE1T1P6Lif (7491), + radioE1T1P6Lods (7492), + radioE1T1P6Lof (7493), + radioE1T1P6Los (7494), + radioE1T1P6Rfi (7495), + radioE1T1P7Ais (7496), + radioE1T1P7Lcd (7497), + radioE1T1P7Lif (7498), + radioE1T1P7Lods (7499), + radioE1T1P7Lof (7500), + radioE1T1P7Los (7501), + radioE1T1P7Rfi (7502), + radioE1T1P8Ais (7503), + radioE1T1P8Lcd (7504), + radioE1T1P8Lif (7505), + radioE1T1P8ods (7506), + radioE1T1P8Lof (7507), + radioE1T1P8Los (7508), + radioE1T1P8Rfi (7509), + radioEthLocOsc (7510), + radioTSProcT (7511), + radioTSProcTODU (7512), + radioFPGAMism (7513), + radioHitlessProtReq (7514), + radioHitlessSwitLoss (7515), + radioHWProtReq (7516), + radioIFMgmt (7517), + radioI2CDev (7518), + radioI2CIf (7519), + radioIduOduOvVol (7520), + radioIduOduEber (7521), + radioIduOduFerf (7522), + radioIduOduLof (7523), + radioIduOduOpCable (7524), + radioIfRxSynth (7525), + radioIfTxSynth (7526), + radioIMAGr1FE (7527), + radioIMAGr1NE (7528), + radioIMAGr2FE (7529), + radioIMAGr2NE (7530), + radioInp1AlStat (7531), + radioInp2AlStat (7532), + radioInp3AlStat (7533), + radioInp4AlStat (7534), + radioInp5AlStat (7535), + radioInp6AlStat (7536), + radioLinkFault (7537), + radioLnkDwnP1 (7538), + radioLnkDwnP2 (7539), + radioLnkDwnP3 (7540), + radioLnkDwnP4 (7541), + radioLocAlmLgOR (7542), + radioLossCap (7543), + radioLossPartCap (7544), + radioMemKeyFail (7546), + radioMismIduOdu (7547), + radioModIfCabF (7548), + radioModFailHSBY (7549), + radioOduCabRg (7550), + radioOduPowFail (7551), + radioOpStat (7552), + radioOpStatP1 (7553), + radioOpStatP2 (7554), + radioOpStatP3 (7555), + radioOpStatP4 (7556), + radioOpStatP5 (7557), + radioOpStatP6 (7558), + radioOpStatP7 (7559), + radioOpStatP8 (7560), + radioParDetFP1 (7561), + radioParDetFP2 (7562), + radioParDetFP3 (7563), + radioParDetFP4 (7564), + radioPowAl (7565), + radioPSAdmStat (7566), + radioPSCMism (7567), + radioR1IfAl (7568), + radioChainNR (7569), + radioTribE1ProtSide (7570), + radioRedundOpStat (7571), + radioRFRxSynth (7572), + radioRFTxSynth (7573), + radioRXAl (7574), + radioSCModIF (7575), + radioSfwrHwMism (7576), + radioSlEquipMod (7577), + radioSlEquipOdu (7578), + radioSlEquipSec (7579), + radioSrcAStatSl6 (7580), + radioSrcAStatSl7 (7581), + radioSrcBStatSl6 (7582), + radioSrcBStatSl7 (7583), + radioSPIDev (7584), + radioSPIIf (7585), + radioSumLicense (7586), + radioSwitchFail (7587), + radioTelemChan (7588), + radioTransPwBias (7589), + radioTransPwDet (7590), + radioTXAl (7591), + radioTXBiasAl (7592), + radioUnkSystT (7593), + radioLoRF (7594), + radioRS (7595), + radioLOFfHSBY (7596), + radioAlignFPS (7597), + radioLinkError (7598), + radioSeqAl (7599), + radioDluFlowAl1 (7601), + radioDluFlowAl2 (7602), + radioDluFlowAl3 (7603), + radioDluFlowAl4 (7604), + radioDluFlowAl5 (7605), + radioDluFlowAl6 (7606), + radioDluFlowAl (7607), + radioDluFlowAl8 (7608), + radioDluFlowAl9 (7609), + radioDluFlowAl10 (7610), + radioDluFlowAl11 (7611), + radioDluFlowAl12 (7612), + radioDluFlowAl13 (7613), + radioDluFlowAl14 (7614), + radioDluFlowAl15 (7615), + radioDluFlowAl16 (7616), + radioDluFlowAl17 (7617), + radioDluFlowAl18 (7618), + radioDluFlowAl19 (7619), + radioDluFlowAl20 (7620), + radioDluFlowAl21 (7621), + radioDluFlowAl22 (7622), + radioDluFlowAl23 (7623), + radioDluFlowAl24 (7624), + radioDluFlowAl25 (7625), + radioDluFlowAl26 (7626), + radioDluFlowAl27 (7627), + radioDluFlowAl28 (7628), + radioDluFlowAl29 (7629), + radioDluFlowAl30 (7630), + radioDluFlowAl31 (7631), + radioDluFlowAl32 (7632), + radioDluFlowAl33 (7633), + radioDluFlowAl34 (7634), + radioDluFlowAl35 (7635), + radioDluFlowAl36 (7636), + radioDluFlowAl37 (7637), + radioDluFlowAl38 (7638), + radioDluFlowAl39 (7639), + radioDluFlowAl40 (7640), + radioDluFlowAl41 (7641), + radioDluFlowAl42 (7642), + radioDluFlowAl43 (7643), + radioDluFlowAl44 (7644), + radioDluFlowAl45 (7645), + radioDluFlowAl46 (7646), + radioDluFlowAl47 (7647), + radioDluFlowAl48 (7648), + radioDluFlowAl49 (7649), + radioDluFlowAl50 (7650), + radioDluFlowAl51 (7651), + radioDluFlowAl52 (7652), + radioDluFlowAl53 (7653), + radioDluFlowAl54 (7654), + radioDluFlowAl55 (7655), + radioDluFlowAl56 (7656), + radioDluFlowAl57 (7657), + radioDluFlowAl58 (7658), + radioDluFlowAl59 (7659), + radioDluFlowAl60 (7660), + radioDluFlowAl61 (7661), + radioDluFlowAl62 (7662), + radioDluFlowAl63 (7663), + radioDluFlowAl64 (7664), + radioDluFlowAl65 (7665), + radioUloFlowAl1 (7666), + radioUloFlowAl2 (7667), + radioUloFlowAl3 (7668), + radioUloFlowAl4 (7669), + radioUloFlowAl5 (7670), + radioUloFlowAl6 (7671), + radioUloFlowAl7 (7672), + radioUloFlowAl8 (7673), + radioUloFlowAl9 (7674), + radioUloFlowAl10 (7675), + radioUloFlowAl11 (7676), + radioUloFlowAl12 (7677), + radioUloFlowAl13 (7678), + radioUloFlowAl14 (7679), + radioUloFlowAl15 (7680), + radioUloFlowAl16 (7681), + radioUloFlowAl17 (7682), + radioUloFlowAl18 (7683), + radioUloFlowAl19 (7684), + radioUloFlowAl20 (7685), + radioUloFlowAl21 (7686), + radioUloFlowAl22 (7687), + radioUloFlowAl23 (7688), + radioUloFlowAl24 (7689), + radioUloFlowAl25 (7690), + radioUloFlowAl26 (7691), + radioUloFlowAl27 (7692), + radioUloFlowAl28 (7693), + radioUloFlowAl29 (7694), + radioUloFlowAl30 (7695), + radioUloFlowAl31 (7696), + radioUloFlowAl32 (7697), + radioInAlTst (7698), + radioInAlWarn (7699), + radioInAlMin (7700), + radioInAlMaj (7701), + radioInAlCrit (7702), + radioAIS (7703), + radioAISlocalIns (7704), + radioAISlocalInsA (7705), + radioAISlocalInsAP (7706), + radioAISlocalInsB (7707), + radioAISlocalInsBP (7708), + radioAISOut (7709), + radioAlignmentFailure1 (7710), + radioAlignmentFailure2 (7711), + radioB1BERexc (7712), + radioBERexc (7713), + radioBERexcHSBY (7714), + radioCardFail (7715), + radioD2mismatch (7716), + radioDluFlow (7717), + radioIDUCF (7719), + radioIFSF (7720), + radioLine1HWp (7721), + radioLine10HWp (7722), + radioLine11HWp (7723), + radioLine12HWp (7724), + radioLine13HWp (7725), + radioLine14HWp (7726), + radioLine15HWp (7727), + radioLine16HWp (7728), + radioLine17HWp (7729), + radioLine18HWp (7730), + radioLine19HWp (7731), + radioLine2HWp (7732), + radioLine20HWp (7733), + radioLine21HWp (7734), + radioLine3HWp (7735), + radioLine4HWp (7736), + radioLine5HWp (7737), + radioLine6HWp (7738), + radioLine7HWp (7739), + radioLine8HWp (7740), + radioLine9HWp (7741), + radioLOF (7742), + radioLOFHSBY (7743), + radioLOS (7744), + radioR2IF (7746), + radioRefSwCh (7747), + radioRS1 (7748), + radioRS2 (7749), + radioRS3 (7750), + radioRS4 (7751), + radioRXHSBY (7753), + radioSWM (7754), + radioFECSDH (7755), + radioFECSDHHSBY (7756), + radioFECSDL (7757), + radioFECSDLHSBY (7758), + radioUHF (7759), + radioUloFlow (7760), + radioWSLOSTx (7761), + radioADMSideFail (7762), + radioPPMissing (7763), + radioOutBufFail (7764), + radioTUG31 (7765), + radioTUG32 (7766), + radioTUG33 (7767), + radioIFFailure (7768), + radioClockLoSync (7769), + radioClockFail (7770), + radioVCXOFail (7771), + radioRxTxCF (7772), + radioSynthFail (7773), + radioIduOduIFLOS (7775), + radioIduOduIFLOSfHSBY (7776), + radioCardOp (7777), + radioMCFEthStatus (7778), + radioMCFQxIFFail (7779), + lossOfSignalPayload (7780), + gfpExtensionHeaderMismatch (7781), + powerSupply1Problem (7782), + powerSupply2Problem (7783), + powerSupply3Problem (7784), + powerSupply4Problem (7785), + voaThresholdCrossed (7786), + cardOverequipped (7787), + oscLossOfLock (7788), + moduleMissing (7789), + moduleNotCertified (7799), + lossOfSignalOSC (7800), + lossOfFrameOSC (7801), + excessiveBitErrorRatioOSC (7802), + degradedSignalOSC (7803), + serverSignalFailPayload (7804), + subrackOverequipped (7805), + subrackMissing (7806), + fanMajorProblem (7807), + fanMinorProblem (7808), + targetNEFailure (7809), + dedicatedPrimaryGatewayFailure (7810), + dedicatedSecondaryGatewayFailure (7811), + notificationQueueOverflow (7812), + requestQueueOverflow (7813), + lofEgress (7814), + serverSignalFailEgress (7815), + syncFailEgress (7816), + mibFailure (7817), + apsMismatch (7818), + serverSignalFailOSC (7819), + pathTraceMismatchEgress (7820), + radioCPSCardFail (7821), + radioBBSPIIntFail (7822), + radioBBI2CIntFail (7823), + radioACCESSSPIIntFail (7824), + radioMatDownloadFailure (7825), + radioMatSwNotAligned (7826), + radioMatSWMismatch (7827), + radioNoActiveCSU (7828), + radioCSUSyncFailed (7829), + radioCUEthernetSwicthFail (7830), + radioCsu1ClockFail (7831), + radioCsu2ClockFail (7832), + radioCsu1GPSClockFail (7833), + radioCsu2GPSClockFail (7834), + radioConfigFail (7835), + radioClockSourceFail (7836), + radioConfigCardStatus (7837), + radioConfigDbError (7838), + radioServiceFlowsNotAlignedWithProfiles (7839), + radioServiceFlowsAlignmentAlrm (7840), + radioExceedingProvisionedServiceFlows (7841), + radioCUProtectionLost (7842), + radioLossOfCarrier (7843), + laserSafetyBusFailure (7844), + compactFlashFailure (7845), + tifSensorActive (7846), + thresholdCVDE15 (7847), + thresholdCVDE15FarEnd (7848), + thresholdCVDE24 (7849), + thresholdCVDE24FarEnd (7850), + thresholdBadFramesRx15 (7851), + thresholdBadFramesRx15FarEnd (7852), + thresholdBadFramesRx24 (7853), + thresholdBadFramesRx24FarEnd (7854), + thresholdBadFramesTx15 (7855), + thresholdBadFramesTx15FarEnd (7856), + thresholdBadFramesTx24 (7857), + thresholdBadFramesTx24FarEnd (7858), + thresholdGoodFramesRx15 (7859), + thresholdGoodFramesRx15FarEnd (7860), + thresholdGoodFramesRx24 (7861), + thresholdGoodFramesRx24FarEnd (7862), + thresholdGoodFramesTx15 (7863), + thresholdGoodFramesTx15FarEnd (7864), + thresholdGoodFramesTx24 (7865), + thresholdGoodFramesTx24FarEnd (7866), + thresholdGoodOctetsRx15 (7867), + thresholdGoodOctetsRx15FarEnd (7868), + thresholdGoodOctetsRx24 (7869), + thresholdGoodOctetsRx24FarEnd (7870), + thresholdGoodOctetsTx15 (7871), + thresholdGoodOctetsTx15FarEnd (7872), + thresholdGoodOctetsTx24 (7873), + thresholdGoodOctetsTx24FarEnd (7874), + thresholdBadGFPSuperblocks15 (7875), + thresholdBadGFPSuperblocks15FarEnd (7876), + thresholdBadGFPSuperblocks24 (7877), + thresholdBadGFPSuperblocks24FarEnd (7878), + thresholdDiscardedGFPframes15 (7879), + thresholdDiscardedGFPframes15FarEnd (7880), + thresholdDiscardedGFPframes24 (7881), + thresholdDiscardedGFPframes24FarEnd (7882), + thresholdBERavg15 (7883), + thresholdBERavg15FarEnd (7884), + thresholdBERavg24 (7885), + thresholdBERavg24FarEnd (7886), + thresholdMaxBER15FarEnd (7887), + thresholdMaxBER24FarEnd (7888), + thresholdPLavg15 (7889), + thresholdPLavg15FarEnd (7890), + thresholdPLavg24 (7891), + thresholdPLavg24FarEnd (7892), + thresholdPLmax15 (7893), + thresholdPLmax15FarEnd (7894), + thresholdPLmax24 (7895), + thresholdPLmax24FarEnd (7896), + thresholdPLmin15 (7897), + thresholdPLmin15FarEnd (7898), + thresholdPLmin24 (7899), + thresholdPLmin24FarEnd (7900), + frequencyMismatchEQPT (7901), + oSCLaserTxFail (7902), + txDegradeEQPT (7903), + txFailEQPT (7904), + alarmIndicationSignal (8000), + lineAlarmIndicationSignal (8001), + msAlarmIndicationSignal (8002), + pathAlarmIndicationSignal (8003), + servicePathAlarmIndicationSignal (8004), + tuAlarmIndicationSignal (8005), + auAlarmIndicationSignal (8006), + plannedCardMismatch (8007), + plannedCardMissing (8008), + rxLossOfClock (8009), + txClockFailure (8010), + dccLinkDown2 (8011), + rxElasticStoreOverflow (8012), + txElasticStoreOverflow (8013), + externalFanFailure (8014), + fanfailure (8015), + fanfailure1 (8016), + fanfailure2 (8017), + fanfailure3 (8018), + fanPowerSupplyFail1 (8019), + fanPowerSupplyFail2 (8020), + felinkDown (8021), + fusefail1 (8022), + fusefail2 (8023), + gfpLossOfCharacterSync (8024), + gfpLossofClientSignal (8025), + gfpLossOfFrameDelimiter (8026), + gfpPayloadTypeMismatch (8027), + gfptclientSignalFailure (8028), + internalHWFailure (8029), + laserBiasEndOfLife (8030), + laserdegrade (8031), + laserTecEndOfLife (8032), + lasertempOutOfRange (8033), + lossOfFrame (8034), + servicePathLossOfFrame (8035), + lossOfFrameAtOtu (8036), + lossOfMultiframe (8037), + tuLossOfMultiframe (8038), + auLossOfPointer (8039), + lossOfPointer (8040), + tuLossOfPointer (8041), + lossOfSignal (8042), + lossofLinkPulse (8043), + lossOfOpticalInputPower (8044), + lossOfOpticalOutputPower (8045), + lossOfSynchronization (8046), + multipleFanFailure (8047), + opticalInputPowerTooHigh (8048), + opticalInputPowerTooLow (8049), + sectionTraceInconsistency (8050), + rsTraceMismatch (8051), + sectiontraceMismatch (8052), + plugInSfpMismatch (8053), + plugInSfpMissing (8054), + plugInSfpNotAdvaApproved (8055), + powersupplyFailure (8056), + protectionGroupProtectionFailure (8057), + protectionGroupprotectionMismatch (8058), + provisionerror (8059), + hpRemoteDefetcIndication (8060), + lineRemoteDefetcIndication (8061), + lpRemoteDefectIndication (8062), + msRemoteDefectIndication (8063), + pathRemoteDefectIndication (8064), + servicePathRemoteDefectIndication (8065), + rxsignalOverload (8066), + msSignalDegraded (8067), + pathSignalDegraded (8068), + sectionSignalDegraded (8069), + hpPayloadMismatch (8070), + lpPayloadMismatch (8071), + pathPayloadMismatch (8072), + servicePathPayloadMismatch (8073), + lossOfSequence (8074), + subModuleTempOutOfRange (8075), + switcherror (8076), + externalInput1 (8077), + externalInput2 (8078), + externalInput3 (8079), + externalInput4 (8080), + externalInput5 (8081), + cv15minThresholdCrossed (8082), + cv24hThresholdCrossed (8083), + es15minThresholdCrossed (8084), + es24hThresholdCrossed (8085), + highCurrentThresholdCrossed (8086), + highestCurrentThresholdCrossed (8087), + highestOipThresholdCrossed (8088), + highestOopThresholdCrossed (8089), + highestTempThresholdCrossed (8090), + highestVoltageThresholdCrossed (8091), + highOipThresholdCrossed (8092), + highOopThresholdCrossed (8093), + highTempThresholdCrossed (8094), + highVoltageThresholdCrossed (8095), + lowCurrentThresholdCrossed (8096), + lowestCurrentThresholdCrossed (8097), + lowestOipThresholdCrossed (8098), + lowestOopThresholdCrossed (8099), + lowestTempThresholdCrossed (8100), + lowestVoltageThresholdCrossed (8101), + lowOipThresholdCrossed (8102), + lowOopThresholdCrossed (8103), + lowTempThresholdCrossed (8104), + lowVoltageThresholdCrossed (8105), + sefs15minThresholdCrossed (8106), + sefs24hThresholdCrossed (8107), + ses15minThresholdCrossed (8108), + ses24hThresholdCrossed (8109), + uas15minThresholdCrossed (8110), + uas24hThresholdCrossed (8111), + txLaserFailure (8112), + hpUnequipped (8113), + lpUnequipped (8114), + pathUnequipped (8115), + servicePathUnequipped (8116), + radioTimeServerMissing (8117), + radioPrioritySessionGranted (8118), + radioEndofCableCompensation (8119), + radioNOIF140 (8120), + radioFPGAIncompatibility (8121), + radioDownloadRequest (8122), + radioStandbySwitch (8123), + radioIfRx (8124), + radioOduIf (8125), + radioClock1LoSync (8126), + radioClock2LoSync (8127), + radioIduOduFerfHWProt (8128), + lossofCommExtShelf (8129), + linkFailure (8130), + sfpAbsent (8131), + imaGrpGrtMismatch (8132), + imaGrpCfgAbt (8133), + imaGrpInsufLnks (8134), + imaGrpStartupFe (8135), + imaGrpCfgAbtFe (8136), + imaGrpInsufLnksFe (8137), + imaGrpBlkFe (8138), + imaLnkLcd (8139), + imaLnkLif (8140), + imaLnkLods (8141), + imaLnkRdi (8142), + imaLnkTxmc (8143), + imaLnkRxmc (8144), + imaLnkTxuuFe (8145), + imaLnkRxuuFe (8146), + sCSWVersionMismatch (8147), + radioAGCOFFinActiveCondition (8148), + radioALCOFFinActiveCondition (8149), + radioBipolarSwitchRequest (8150), + radioBSWForcedSwitch (8151), + radioBSWLockout (8152), + radioBSWManualSwitch (8153), + radioBSWTraffictoProtection (8154), + radioCarrierWaveinActiveCondition (8155), + radioCNCTLossofClockSignal6MHz (8156), + radioCNCTLossOfProtectionSignal (8157), + radioEcuUnitRemoved (8158), + radioEPSOFFinActiveCondition (8159), + radioExternalReferenceClockCutoff (8160), + radioForcedSwitch (8161), + radioFrequencyMeasurement (8162), + radioLoopback (8163), + radioManualSwitch (8164), + radioManualSwitchState (8165), + radioNetworkReferenceClockQualityDown (8166), + radioRemoteCardIdentifier (8167), + radioRSPIUnavailableStateRP (8168), + radioRXLocalInternalClock (8169), + radioSDDADEinActiveCondition (8170), + radioSynchStatusChanged (8171), + radioUASFarEndBlockError (8172), + radioUnavailableStateB1 (8173), + radioUnavailableStateB2 (8174), + radioUnipolarSwitchRequest (8175), + radioUserChannelLossofSignal (8176), + radioUSWForcedSwitch (8177), + radioUSWLockout (8178), + radioUSWManualSwitch (8179), + radioUSWTraffictoProtection (8180), + radioWaySideRFCOHLOS (8181), + radioWaySideSOHLOS (8182), + radioWorkingEquipSwitchedToProtection (8183), + radioFanRequired (8184), + radioLocalSync (8185), + communicationFailure (8186), + unauthorizedAccessAttempt (8187), + pllUnlock (8188), + radioODUUnsupportedDynamicModulation (8189), + radioModeAlign (8190), + radioBoostOnlevel1 (8191), + radioBoostOnlevel2 (8192), + radioBoostOnlevel3 (8193), + radioBoostOnlevel4 (8194), + radioBoostOnlevel5 (8195), + radioLocalAISInsertionOnHalfPayload (8196), + radioTxONforProtectingODUAlarm (8197), + noFreeLowOrderCapacity (8198), + lowOrderCapacityMismatch (8199), + radioOperationalStatusQ0 (8200), + radioOperationalStatusQ1 (8201), + radioOperationalStatusF (8202), + radioOperationalStatusVbus (8203), + radioOperationalStatusOSI1 (8204), + radioOperationalStatusOSI2 (8205), + radioOperationalStatusOSI3 (8206), + radioOperationalStatusOSI4 (8207), + radioOperationalStatusOSI5 (8208), + radioOperationalStatusOSI6 (8209), + radioOperationalStatusOSI7 (8210), + radioOperationalStatusOSI8 (8211), + radioOperationalStatusOSI9 (8212), + radioOperationalStatusOSI10 (8213), + radioOperationalStatusOSI11 (8214), + radioOperationalStatusOSI12 (8215), + radioOperationalStatusOSI13 (8216), + radioOperationalStatusOSI14 (8217), + radioOperationalStatusOSI15 (8218), + radioOperationalStatusOSI16 (8219), + radioSNMPAuthenticationFailure (8220), + radioSFPMissing (8221), + radioUnsupportedSFPType (8222), + radioEthSwitchGbEthPortLOS (8223), + radioSFPTxFault (8224), + radioEthSwitchLAN1PortLinkNotPresent (8225), + radioEthSwitchLAN2PortLinkNotPresent (8226), + radioEthSwitchLAN3PortLinkNotPresent (8227), + radioEthSwitchGbEthPortLinkNotPresent (8228), + radioLastTemporizedOperationFail (8229), + radioEthSwitchTrunk1CapacityMismatch (8230), + radioEthSwitchTrunk2CapacityMismatch (8231), + radioExpectedSVRMismatch (8232), + radioBER4 (8233), + radioBER5 (8234), + radioBER6 (8235), + radioBER7 (8236), + radioFaultinEquipment (8237), + radioForcedControlOn (8238), + radioFaultinInstallationofEquipment (8239), + radioFaultinChangeOverFunction (8240), + radioEquipmentDoorOpen (8241), + radio15minG826ESThresholdCrossed (8242), + radio15minG826SESThresholdCrossed (8243), + radio15minG826BBEThresholdCrossed (8244), + radioUnavailability (8245), + radioTestModeActive (8246), + radioTestGeneratorOn (8247), + radioFaultInOscillator (8248), + radioOperatingError (8249), + radioRealTimeLostFault (8250), + radioConfigurationError (8251), + radioLicenceExpired (8252), + radioLicenceWillExpireinNearFuture (8253), + radioLicenceforFeatureIsNotAvailable (8254), + radioFarEndAlarm (8255), + radioBufferOverflow (8256), + radioFaultinUnit (8257), + radioActiveAlarmPoint (8258), + radioNoFreeChannel (8259), + radioIncomingSignalLevelIncorrect (8260), + radioNoIncomingRadioSignal (8261), + radioCorruptData (8262), + radioNoOutgoingRadioSignal (8263), + radioCommFailure (8264), + radioCardRemoved (8265), + radioCardInstalled (8266), + radioUnlock (8267), + radioRSLLow (8268), + radioSynthesizerUnlock (8269), + radioSNRLow (8270), + radioLowBatteryVoltage (8271), + radioRemotefaultEast (8272), + radioPowerUp (8273), + radioReboot (8274), + radioNTPUpdate (8275), + radioE1Disconnected (8276), + radioRemoteFaultWest (8277), + radioEncryptionFailure (8278), + radioEncryptionOneway (8279), + radioExternalAlarm1 (8280), + radioExternalAlarm2 (8281), + radioExternalAlarm3 (8282), + radioExternalAlarm4 (8283), + radioRemoteIDUAlarm (8284), + radioRemoteIDUExternalAlarm1 (8285), + radioRemoteIDUExternalAlarm2 (8286), + radioRemoteIDUExternalAlarm3 (8287), + radioRemoteIDUExternalAlarm4 (8288), + radioBERTLbTestMode (8289), + radioProtectionSwitchFailure (8290), + radioATPCTxatMaxPower (8291), + radioE1TestMode (8292), + radioTestMode (8293), + radioLossOfClock (8294), + radioRSB1Defect (8295), + radioRSLossOfFrame (8296), + radioRSOutOfFrame (8297), + radioMSRemoteError (8298), + radioMSRemoteDefect (8299), + radioMSB2Defect (8300), + radioAUAIS (8301), + radioAULossOfPointer (8302), + radioHPUnequipped (8303), + radioHPTraceIdentifierMismatch (8304), + radioHPRemoteError (8305), + radioHPRemoteDefect (8306), + radioHPPathLabelMismatch (8307), + radioHPB3Defect (8308), + radioTULossOfMultiframe (8309), + radioTUAIS (8310), + radioTULossOfPointer (8311), + radioLPUnequipped (8312), + radioLPTraceIdentifierMismatch (8313), + radioLPRemoteError (8314), + radioLPRemoteDefect (8315), + radioLPPathLabelMismatch (8316), + radioLPRemoteFault (8317), + radioLPBIP2Defect (8318), + radioLinkReconfigurationFailure (8319), + radioFPGAProgrammingFailure (8320), + radioReceiveProtectionSwitchFailure (8321), + radioPDHProtectionSwitch (8322), + radioSFPModuleInstalled (8323), + radioSFPModuleRemoved (8324), + radioSFPModuleTxFault (8325), + radioSFPPayloadDisconnected (8326), + radioEthernetDisconnected (8327), + radioODUModeNotAuthorized (8328), + radioIDUModeNotAuthorized (8329), + radioOpticalAlarm1 (8330), + radioOpticalAlarm2 (8331), + radioOpticalAlarm3 (8332), + radioOpticalAlarm4 (8333), + radioGbEthAlarm1 (8334), + radioGbEthAlarm2 (8335), + radioGbEthAlarm3 (8336), + radioGbEthAlarm4 (8337), + radioACMSwitchUpper (8338), + radioACMSwitchLower (8339), + radioOvercurrentUndercurrentODUPSCondition (8340), + radioSerialNumberMemoryKeywithmismatchingcontent (8341), + radioSystemTypeMemoryKeywithmismatchingcontent (8342), + radioPowerSupplytoODUFailure (8343), + radioUNIShutdownCCMDisabled (8344), + radioIDUsmisconfiguration (8345), + radioProtectionManualOperation (8346), + radioProtectionSystemFailure (8347), + radioProtectionSelfTestFailure (8348), + radioProtectionSoftwareSwitchNotAllowed (8349), + radioPortSpeedUnderLimiter (8350), + radioPortSpeedUnderCIRSum (8351), + radioServiceStatusDown (8352), + radioServiceCCMLoss (8353), + radioUNIShutdown (8354), + radioPWOperationalStatusDown (8355), + radioPWRemotePacketLoss (8356), + radioELPSProtectionPathFailure (8357), + radioELPSWorkingPathFailure (8358), + radioELPSAPSSwitchFailed (8359), + radioELPSMismatch (8360), + radioIUOUCableE1NumberOverflow (8361), + radioCardAbsent (8362), + radioCCMforUNIShutdownDisabled (8363), + radioTxRxE1NumberMismatch (8364), + radioMemoryKeyExtracted (8365), + radioNEOverheating (8366), + radioOpticalSFPLossOfSignal (8367), + radioOpticalSFPTXFault (8368), + radioPortFailure (8369), + radioSourceClockDeteriorate (8371), + radioSignalDegrade (8372), + radioJ2TraceIdentifierMismatch (8374), + radioLoopProtectionE1AIS (8375), + radioTXPowerAlarm (8376), + radioProtectionHSBYConfigurationError (8377), + radioProtectionModeMismatchinColocatedODU (8378), + radioIDUContinuityCheckLoss (8379), + radioColocatedMEPState (8380), + radioOneSynchSourceDown (8381), + radioSSMMissing (8382), + radioCableInterfaceNotHybridIDU (8383), + radioCableInterfacePacketDischarging (8384), + radioCableInterfacePortMauStatusDown (8385), + radioODUODUPortMauStatusDown (8386), + radioODUODUPortOperationalstatusdown (8387), + radioATPCautodisabled (8388), + radioHighBER (8389), + radioConfigurationNotSupported (8390), + radioWrongRoleorPriorityConfiginPairedODUGroup (8391), + radioSystemTypeMismatchinPairedODUGroup (8392), + radioFragmentationOperationalStatus (8393), + radioDCCFailure (8394), + radioB2computedBERthreshold (8395), + radioLossofPointerTX (8396), + radioAISTX (8397), + rmtLOS (8700), + rmtLOF (8701), + rmtOOF (8702), + rmtRSTIM (8703), + rmtRSEXC (8704), + rmtRSDEG (8705), + rmtMSAIS (8706), + rmtMSRDI (8707), + rmtMSEXC (8708), + rmtMSDEG (8709), + rmtAUAIS (8710), + rmtAULOP (8711), + rmtHPTIM (8712), + rmtHPUNEQ (8713), + rmtHPPLM (8714), + rmtHPRDI (8715), + rmtHPEXC (8716), + rmtHPDEG (8717), + rmtTULOP (8718), + rmtTULOM (8719), + rmtTUAIS (8720), + rmtLPTIM (8721), + rmtLPUNEQ (8722), + rmtLPPLM (8723), + rmtLPRDI (8724), + rmtLPEXC (8725), + rmtLPDEG (8726), + rmtKByteMismatch (8727), + rmtPAIS (8728), + rmtLsrMisMatch (8729), + rmtLsrOffLine (8730), + rmtPKGFAIL (8731), + rmtPKGTYPE (8732), + rmtPKGREMOVED (8733), + rmtSYSLTI (8734), + rmtSYSLTO (8735), + rmtSYNCLOS (8736), + rmtSYNCLOF (8737), + rmtSYNCAIS (8738), + rmtSYNCBAD (8739), + rmtSYNCSSMMismatch (8740), + rmtPTPLOT (8741), + rmtPTPLOS (8742), + rmtPowerFail (8743), + rmtHighTemp (8744), + rmtLowTemp (8745), + rmtFANFAIL (8746), + rmtELinkFail (8747), + rmtSWPKG-MISMATCH (8748), + rmtHighSysMem (8749), + rmtHighRootfs (8750), + rmtHighAppdisk (8751), + rmtAIS (8752), + rmtRDI (8753), + rmtLOC (8754), + rmtLCK (8755), + rmtMismerge (8756), + rmtUnexpMep (8757), + rmtUnexpPrd (8758), + rmtUnexpMel (8759), + rmtCSF (8760), + rmtAPSMismatch (8761), + rmtLOPS (8762), + rmtTSF (8763), + rmtSlotConfigError (8764), + rmtPKGNOTREADY (8765), + rmtCES-RDI (8766), + rmtCES-AIS (8767), + rmtBUSERROR (8768), + rmtOUTSIDEALM1 (8769), + rmtOUTSIDEALM2 (8770), + rmtOUTSIDEALM3 (8771), + rmtOUTSIDEALM4 (8772), + rmtOUTSIDEALM5 (8773), + rmtOUTSIDEALM6 (8774), + rmtOUTSIDEALM7 (8775), + rmtOUTSIDEALM8 (8776), + rmtARP-REACH-MAX (8777), + rmtSD (8778), + rmtSF (8779), + rmtONU-MISMATCH (8780), + rmtXCON (8781), + rmtERROR-CCM (8782), + rmtSomeRDI (8783), + rmtSomeRmepCCM (8784), + rmtPTSF-lossSync (8785), + rmtPTSF-lossAnnounce (8786), + rmtTOD-MonitorAlarm (8787), + rmtAppdiskErr (8788), + rmtSSF (8789), + rmtSSD (8790), + rmtSYNC-Low-QL (8791), + rmtEthLpb (8792), + rmtTNL-SD (8793), + rmtTNL-SF (8794), + otnLosAlarm (9000), + otnLofAlarm (9001), + otnLomAlarm (9002), + otnWavelengthlockAlarm (9003), + otnOtuAisAlarm (9004), + otnOtuBdiAlarm (9005), + otnOtuTtimAlarm (9006), + otnOtuIaeAlarm (9007), + otnOtuSdAlarm (9008), + otnOtuSfAlarm (9009), + otnOtuFecExcessiveErrsAlarm (9010), + otnOtuFecDegradedErrsAlarm (9011), + otnOtuBbeThreholdAlarm (9012), + otnOtuEsThreholdAlarm (9013), + otnOtuSesThreholdAlarm (9014), + otnOtuUasThreholdAlarm (9015), + otnOduAisAlarm (9016), + otnOduOciAlarm (9017), + otnOduLckAlarm (9018), + otnOduBdiAlarm (9019), + otnOduTtimAlarm (9020), + otnOduSdAlarm (9021), + otnOduSfAlarm (9022), + otnOduRxApsChange (9023), + otnOduBbeThreholdAlarm (9024), + otnOduEsThreholdAlarm (9025), + otnOduSesThreholdAlarm (9026), + otnOduUasThreholdAlarm (9027), + otnOpuPMTAlarm (9028), + sFWU (9100), + sFWAZW (9101), + sFWZAW (9102), + sFWAZP (9103), + sFWZAP (9104), + sFPU (9105), + sFPAZW (9106), + sFPZAW (9107), + sFPAZP (9108), + sFPZAP (9109), + sMWU (9110), + sMWAZW (9111), + sMWZAW (9112), + sMWAZP (9113), + sMWZAP (9114), + sMPU (9115), + sMPAZW (9116), + sMPZAW (9117), + sMPAZP (9118), + sMPZAP (9119), + sCU (9120), + sCAZW (9121), + sCZAW (9122), + sCAZP (9123), + sCZAP (9124), + airCompressorFail (9200), + airConditioningFail (9201), + airDryerFail (9202), + bampFail1 (9203), + bampFail2 (9204), + bampFail3 (9205), + bampFail4 (9206), + bampWarn1 (9207), + bampWarn2 (9208), + bampWarn3 (9209), + bampWarn4 (9210), + batteryDischarg (9211), + batteryFail (9212), + coolingFanFail (9213), + centralizedPowerMajor (9214), + centralizedPowerMinor (9215), + craFail1 (9216), + craFail2 (9217), + craFail3 (9218), + craFail4 (9219), + craWarn1 (9220), + craWarn2 (9221), + craWarn3 (9222), + craWarn4 (9223), + engineFail (9224), + engineOperating (9225), + standbyEngineTransfer (9226), + expGas (9227), + fireDetectorFail (9228), + tlFire (9229), + tlFlood (9230), + fuelLeak (9231), + fuseFail (9232), + gasAlarm (9233), + generatorFail (9234), + cEVHatchFail (9235), + highAirflow (9236), + highHumid (9237), + highTemp (9238), + tlHighWater (9239), + intruder (9240), + secADSLVoltageDisc (9241), + lowBatteryVoltage (9242), + tlLowFuel (9243), + lowHumid (9244), + tlLowCablePressure (9245), + lowTemp (9246), + tlLowWater (9247), + miscellaneous (9248), + nirFail1 (9249), + nirFail2 (9250), + nirFail3 (9251), + nirFail4 (9252), + nirWarn1 (9253), + nirWarn2 (9254), + nirWarn3 (9255), + nirWarn4 (9256), + openDoor (9257), + comPowerFailure (9258), + powerSupplyMajor (9259), + powerSupplyMinor (9260), + pumpFailure (9261), + rectifierFail (9262), + rectifierHighVoltage (9263), + rectifierLowVoltage (9264), + rectifierPowerFailADSL (9265), + rectifierPowerFailTrans (9266), + rectifierPowerFailDCL (9267), + commACFail (9268), + acPowerLoss (9269), + retrieveStdbyEng (9270), + tlSmoke (9271), + highLowTemperature (9272), + tlToxicGas (9273), + tRepeater (9274), + ventSystemFailure (9275), + thresholdBCPKT15 (9276), + thresholdBCPKT24 (9277), + thresholdBEFEC15 (9278), + thresholdBEFEC24 (9279), + thresholdBERFEC15 (9280), + thresholdBERFEC24 (9281), + thresholdCRCAE15 (9282), + thresholdCRCAE24 (9283), + thresholdCVOTU15 (9284), + thresholdCVOTU24 (9285), + thresholdCVS15 (9286), + thresholdCVS24 (9287), + thresholdDELAYODUHT15 (9288), + thresholdDELAYODUHT24 (9289), + thresholdDELAYODULT15 (9290), + thresholdDELAYODULT24 (9291), + thresholdDELAYODUTHT15 (9292), + thresholdDELAYODUTHT24 (9293), + thresholdDELAYODUTLT15 (9294), + thresholdDELAYODUTLT24 (9295), + thresholdDGDHT15 (9296), + thresholdDGDHT24 (9297), + thresholdDROP15 (9298), + thresholdDROP24 (9299), + thresholdEBODU15 (9300), + thresholdEBODU24 (9301), + thresholdEBODUT15 (9302), + thresholdEBODUT24 (9303), + thresholdEBOTU15 (9304), + thresholdEBOTU24 (9305), + thresholdESODU15 (9306), + thresholdESODU24 (9307), + thresholdESODUT15 (9308), + thresholdESODUT24 (9309), + thresholdESOTU15 (9310), + thresholdESOTU24 (9311), + thresholdESS15 (9312), + thresholdESS24 (9313), + thresholdFRAG15 (9314), + thresholdFRAG24 (9315), + thresholdJABR15 (9316), + thresholdJABR24 (9317), + thresholdLOSS15 (9318), + thresholdLOSS24 (9319), + thresholdMCPKT15 (9320), + thresholdMCPKT24 (9321), + thresholdOPRHT15 (9322), + thresholdOPRHT24 (9323), + thresholdOPRLT15 (9324), + thresholdOPRLT24 (9325), + thresholdOSPKT15 (9326), + thresholdOSPKT24 (9327), + thresholdPKT15 (9328), + thresholdPKT24 (9329), + thresholdSE15 (9330), + thresholdSE24 (9331), + thresholdSEFSS15 (9332), + thresholdSEFSS24 (9333), + thresholdSESODU15 (9334), + thresholdSESODU24 (9335), + thresholdSESODUT15 (9336), + thresholdSESODUT24 (9337), + thresholdSESOTU15 (9338), + thresholdSESOTU24 (9339), + thresholdSESS15 (9340), + thresholdSESS24 (9341), + thresholdUASODU15 (9342), + thresholdUASODU24 (9343), + thresholdUASODUT15 (9344), + thresholdUASODUT24 (9345), + thresholdUASOTU15 (9346), + thresholdUASOTU24 (9347), + thresholdUBEFEC15 (9348), + thresholdUBEFEC24 (9349), + thresholdUSPKT15 (9350), + thresholdUSPKT24 (9351), + thresholdUTILHT15 (9352), + thresholdUTILHT24 (9353), + thresholdBBERS15 (9354), + thresholdBBERS24 (9355), + thresholdESRS15 (9356), + thresholdESRS24 (9357), + thresholdOFSRS15 (9358), + thresholdOFSRS24 (9359), + thresholdSESRS15 (9360), + thresholdSESRS24 (9361), + thresholdBBEMS15 (9362), + thresholdBBEMS24 (9363), + thresholdCVL15 (9364), + thresholdCVL24 (9365), + thresholdESL15 (9366), + thresholdESL24 (9367), + thresholdESMS15 (9368), + thresholdESMS24 (9369), + thresholdFCL15 (9370), + thresholdFCL24 (9371), + thresholdFCMS15 (9372), + thresholdFCMS24 (9373), + thresholdLBCHT15 (9374), + thresholdLBCHT24 (9375), + thresholdLBCLT15 (9376), + thresholdLBCLT24 (9377), + thresholdLTHT15 (9378), + thresholdLTHT24 (9379), + thresholdLTLT15 (9380), + thresholdLTLT24 (9381), + thresholdSESMS15 (9382), + thresholdSESMS24 (9383), + thresholdUASL15 (9384), + thresholdUASL24 (9385), + thresholdUASMS15 (9386), + thresholdUASMS24 (9387), + thresholdSESL15 (9388), + thresholdSESL24 (9389), + remoteLinkFailure (9390), + tellabsLayer2ResLow (9391), + tellabsLayer2ResUnavail (9392), + tellabsAdminUnitLossOfPointer (9393), + tellabsAdminUnitAlarmIndicationSignal (9394), + tellabsHOPathBersd (9395), + tellabsHOPathBersf (9396), + tellabsHOPathPlm (9397), + tellabsHOPathRfi (9398), + tellabsHOPathUneq (9399), + tellabsEthernetBersd (9400), + tellabsEthernetBersf (9401), + tellabsEthernetLinkFlap (9402), + tellabsEthernetRdi (9403), + failureOfProtocolReceive (9404), + memberNotDeskewable (9405), + tellabsEthernetRcvPlc (9406), + tellabsEthernetRcvTlc (9407), + tellabsEvcLoop (9408), + thresholdBBEHP15 (9409), + thresholdBBEHP24 (9410), + thresholdESHP15 (9411), + thresholdESHP24 (9412), + thresholdSESHP15 (9413), + thresholdSESHP24 (9414), + thresholdFCHP15 (9415), + thresholdFCHP24 (9416), + thresholdUASHP15 (9417), + thresholdPJCDIFFP15 (9418), + thresholdPJCDIFFP24 (9419), + thresholdPJCSPDET15 (9420), + thresholdPJCSPDET24 (9421), + thresholdPJCSPGEN15 (9422), + thresholdPJCSPGEN24 (9423), + tellabsPowerFuseProblemA (9424), + tellabsPowerFuseProblemB (9425), + tellabsShNumberIncorrect (9426), + tellabsHighSpeedFan (9427), + tellabsInhAlm (9428), + tellabsThermalProblemUSS (9429), + tellabsThermalProblemNano (9430), + tellabsAISPath (9431), + tellabsBersdPath (9432), + tellabsBersfPath (9433), + tellabsLopPath (9434), + tellabsPlmPath (9435), + tellabsRfiPath (9436), + tellabsUnequippedPath (9437), + thresholdCVP15 (9438), + thresholdCVP24 (9439), + thresholdESP15 (9440), + thresholdESP24 (9441), + thresholdSESP15 (9442), + thresholdSESP24 (9443), + thresholdFCP15 (9444), + thresholdFCP24 (9445), + thresholdUASP15 (9446), + thresholdUASP24 (9447), + snmpEngineConnFailure (9448), + checkHECgfpFailure (9449), + payloadLengthIndicatorGfp (9450), + tellabsRemoteLinkFailure (9451), + sequenceMismatch (9452), + autoNegFail (9453), + tellabsThermalProblemPico (9454), + snmpTrapRegisterFailure (9455), + swUpgradeCommit (9456), + softwareExecPartial (9457), + softwareAbortProgress (9458), + softwareAbortFail (9459), + softwareAbortCompleted (9460), + thresholdCDLT15 (9461), + thresholdCDHT15 (9462), + thresholdCDLT24 (9463), + thresholdCDHT24 (9464), + thresholdOSNRLT15 (9465), + thresholdOSNRLT24 (9466), + tlabMACPortLinkFlappingNotif (9467), + tlabMACSDNotif (9468), + tlabMACSFNotif (9469), + tlabLAGInterfaceFailureNotif (9470), + tlabMACTRDIENotif (9471), + tlabMACLOSSYNCNotif (9472), + tlabMACLOSNotif (9473), + tlabMIEcfmdot1agRDICCMNotif (9475), + tlabMIEcfmdot1agRemoteMepCCMNotif (9476), + tlabMIEcfmdot1agErrorCCMNotif (9477), + tlabMIEcfmdot1agXconCCMNotif (9478), + fabCapacityDeficiency (9479), + tlabElpsProtectionTypeMismatchNotif (9480), + tlabElpsConfigurationMismatchNotif (9481), + tlabElpsLackOfResponseNotif (9482), + tlabElpsProtectionGroupFailedNotif (9483), + tlabElpsFailureOfProtocolNotif (9484), + lossOfFrameDelineationGfp (9485), + payloadLabelMismatchGFP (9486), + fopNoResponse (9487), + fopProvisioningMismatch (9488), + linkAggregationControlProtocolFailure (9489), + backwardInLos (9490), + forwardInLos (9491), + forwardOscDitherLos (9492), + backwardOscDitherLos (9493), + lowEdfaInputPower (9494), + highBackReflectionPower (9495), + highLineOutputPower (9496), + lowLineOutputPower (9497), + shutdownAmbientTemperature (9498), + warningAmbientTemperature (9499), + oduPlm (9500), + oduMsim (9501), + otuLof (9502), + otuLom (9503), + otuTim (9504), + otuBdi (9505), + otuDeg (9506), + oduLofLom (9507), + oduAis (9508), + oduLck (9509), + oduOci (9510), + oduTim (9511), + oduBdi (9512), + oduDeg (9513), + lossOip (9514), + oopFail (9515), + ldFail (9516), + wControl (9517), + dcn2mLos (9518), + cardInitializationInProgress (9519), + dataRateMismatchGFP (9520), + unexpectedChannelIDGFP (9521), + outOfSequenceGFP (9522), + clientSignalFailLossOfCharacterSynchronisationGFP (9523), + noFramesReceivedGFP (9524), + latchOpen (9525), + sEF (9526), + accountExpiredDisabled (9527), + callFailure (9528), + otsRecoverMode (9529), + ramanGainProblem (9530), + ramanGainCritical (9531), + fanUnit1Failure (9532), + fanUnit2Failure (9533), + fanUnit3Failure (9534), + fanUnit4Failure (9535), + fanUnit5Failure (9536), + fanUnit6Failure (9537), + fanUnit7Failure (9538), + fanUnit8Failure (9539), + excessiveTempVariation (9540), + thresholdFcse15 (9541), + thresholdFcse24 (9542), + thresholdDf15 (9543), + thresholdDf24 (9544), + thresholdFcseAsap (9545), + thresholdDfAsap (9546), + thresholdDm (9547), + thresholdMaxDm (9548), + thresholdDmAsap (9549), + thresholdMaxDmAsap (9550), + reduceLogOverload (9551), + gfptClientSignalFailureSec (9552), + lossOfFrameDelineationSec (9553), + hcoc9Dcf (9554), + hcoc27Dcf (9555), + systemClockUnlock (9556), + xfpMismatch (9557), + xfpWavOffset (9558), + xfpWavSetError (9559), + portinLoopback (9560), + xconCCMdefect (9561), + errorCCMdefect (9562), + someRMEPCCMdefect (9563), + someRDIdefect (9564), + callSurvivabilityDegrade (9565), + neighborUnreachable (9566), + atmLcd (9567), + atmCcloc (9568), + atmVpais (9569), + atmVprdi (9570), + atmVploc (9571), + atmVcais (9572), + atmVcrdi (9573), + atmVcloc (9574), + atmLif (9575), + atmLods (9576), + atmRdiIma (9577), + atmTxMisConnected (9578), + atmRxMisConnected (9579), + atmTxUnusableFe (9580), + atmRxUnusableFe (9581), + atmStartupFe (9582), + atmConfigAborted (9583), + atmConfigAbortedFe (9584), + atmInsufficientLinks (9585), + atmInsufficientLinksFe (9586), + atmBlockedFe (9587), + atmGrTimingMismatch (9588), + sc-mib-sync (9589), + ospf-auth-key-exp (9590), + xfp-crossing-threshold (9591), + hocc-asic-failure (9592), + pumpsEol (9593), + pumpsShutdownTemperature (9594), + pumpsWarningTemperature (9595), + pwrSupplyFailure (9596), + aprShd (9597), + fiberDeteriorate (9598), + builtInTestFailed (9599), + oSCbandLos (9600), + powerSupplyFailure1U (9601), + fanFailure1U (9602), + powerAMissing (9603), + powerBMissing (9604), + constituentAttributeMismatch (9605), + partialLossOfCapacity (9606), + totalLossOfCapacity (9607), + tlabPktTpOamMepLDINotif (9608), + tlabPktTpOamMepLOCNotif (9609), + tlabPktTpOamMepMCNotif (9610), + tlabPktTpOamMepRDINotif (9611), + tlabPktTpOamMepUNPNotif (9612), + lAGprotectionNotAvailable (9613), + eLPSAPSMessageNotReceived (9614), + eLPSProtectionNotAvailable (9615), + eRPSvLANProtectionNotAvailable (9616), + failedRestorePacketDB (9617), + autoNegotiationFail (9618), + lossOfSignalInGFP (9619), + lossOfSyncInGFP (9620), + fabricConfigurationIsInvalid (9621), + softwareUpgradeActionRequired (9622), + radioNearendLOF (9667), + radioNearendLossOfSignal (9668), + radioNearendsendingLOFIndication (9669), + radioFarendsendingAIS (9671), + radioFarEndSendingTS16LOMF (9672), + radioNearEnddetectsatestcode (9673), + radioNearEndinUnavailableSignalState (9674), + radioNearendsendingAIS (9675), + radioNearEndSendingTS16LOMF (9676), + radioOperationalstatusDown (9677), + radioPrimaryclocksourcefailed (9678), + radioLossofinputsignal (9679), + radioLPG701OperationalstatusDown (9680), + radioLPG702OperationalstatusDown (9681), + radioLPG703OperationalstatusDown (9682), + radioLPG704OperationalstatusDown (9683), + radioLPG705OperationalstatusDown (9684), + radioLPG706OperationalstatusDown (9685), + radioLPG707OperationalstatusDown (9686), + radioLPG708OperationalstatusDown (9687), + radioLPG709OperationalstatusDown (9688), + radioLPG710OperationalstatusDown (9689), + radioLPG711OperationalstatusDown (9690), + radioLPG712OperationalstatusDown (9691), + radioLPG713OperationalstatusDown (9692), + radioLPG714OperationalstatusDown (9693), + radioLPG715OperationalstatusDown (9694), + radioIDUMEPOperationalStatus (9695), + radioProtectionMEPOperationalStatus (9696), + radioIDUMEPRemoteDefectIndication (9697), + radioProtectionMEPRemoteDefectIndication (9698), + radioProtectionMEPContinuityCheckLoss (9699), + radioLPGFailure (9700), + radioIDUMEPConfigurationError (9701), + radioProtectionMEPConfigurationError (9702), + radioLossofairflowfailure (9703), + radioFantraypulledout (9704), + radioModuleInsertedincorrectly (9705), + radioPowerSupplyOverheat (9706), + radioDeviceoverheat (9707), + radioDeviceunderheat (9708), + radioProbleminallpowersupplies (9709), + radioTXPowerSupplyFail (9710), + radioFan1failure (9711), + radioFan2failure (9712), + radioFan3failure (9713), + radioFan4failure (9714), + radioPower1InVoltageoutofrange (9715), + radioPower1OutProbleminPSoutput (9716), + radioModuleInsertedbutnotenabled (9717), + radioDryContactInput1 (9718), + radioDryContactInput2 (9719), + radioRxopticalpowerabovemaxthreshold (9720), + radioRxopticalpowerbelowminthreshold (9721), + radioAutonegspeedmismatchallocatedBWonport (9722), + radioCarrierEquipmentOutofService (9723), + radioPower2InVoltageoutofrange (9724), + radioPower2OutProbleminPSoutput (9725), + radioDryContactInput3 (9726), + radioDryContactInput4 (9727), + radioSoftwareSwitchNotAllowed (9728), + radioConfigdirectoryoversizelimit (9729), + radioCLIsecurityalert (9730), + radioIDUMEPContinuityCheckLoss (9731), + radioLPGConfigurationError (9732), + radioFarendLOF (9733), + radioFailure (9734), + radioLossofCableFrame (9735), + radioSignalLevelUnderThreshold (9736), + radioNotHybridIDU (9737), + radioColocatedODUCommunicationFailure (9738), + radioPacketsfromIDUDischargedbyODU (9739), + radioWrongRole-PriorityConfiguration (9740), + radioSystemTypeMismatchonColocatedODU (9741), + radioIDUCCMContinuityCheckLoss1plus1 (9742), + radioProtectionCCMContinuityCheckLoss (9743), + radioIDUCCMPeerMEPStateDown (9744), + radioProtectionCCMPeerMEPStateDown (9745), + radioIDUCCMCfgError1plus1 (9746), + radioProtectionCCMCfgError (9747), + radioIDUCCMRDIbitinthelastreceivedCCM (9748), + radioProtectionCCMRDIbitinthelastreceivedCCM (9749), + radioScheduledActionFailure (9750), + radiohybrid-packetmismatch (9751), + radioSystemEthernetPort (9752), + radioHSBYConfigurationError (9753), + radioMasterA-CCMLoss (9754), + radioSlaveA-CCMLoss (9755), + radioE-CCMLoss (9756), + radioMasterA-CCMConfigurationError (9757), + radioSlaveA-CCMConfigurationError (9758), + radioMasterRDIreceivedinthelastA-CCM (9759), + radioSlaveRDIreceivedinthelastA-CCM (9760), + radioRDIreceivedinthelastE-CCM (9761), + radioPWoperationalstatuswaschangedfromstoup (9762), + radioStationAlarmOn (9763), + radioStationAlarmOff (9764), + radioPowerSupplyFailuretoODU (9765), + radioOperationalstatuswaschangedfromuptos (9766), + radioODUStatusfailed (9767), + radioODUStatusabsent (9768), + radioIU-OULOFAlarm (9769), + radioIU-OUCablemultiframeLoss (9770), + radioOUIU-OUMacAddressMismatch (9771), + radioIU-OURxE1NumberMismatch (9772), + radioIU-OUTxE1NumberMismatch (9773), + radioIU-OUEthernetpacketsdroppedbyFCSerror (9774), + radioradioLinkStatusDown (9775), + radio1731AIS (9776), + radioJ0TraceIdentifierMismatch (9777), + radioRSDegrade (9778), + radioMSDegrade (9779), + radioJ1TraceIdentifierMismatch (9780), + radioLPTULossOfPointer (9781), + radioLPTUAlarmIndicationSignal (9782), + radioLPDegrade (9783), + radioLPJ2TraceIdentifierMismatch (9784), + radioHPDegrade (9785), + radioHPExcessiveError (9786), + radioMSExcessiveError (9787), + radioDebugModeOn (9788), + radioDebugModeOff (9789), + radioManualOperationOn (9790), + radioManualOperationOff (9791), + radioSynchronization (9792), + radioOAMRDI (9793), + radioRemoteIDUCCMMEPState (9794), + radioRemoteProtectionCCMMEPState (9795), + radioE-CCMCfgError (9796), + radioradioRfRXsignal (9797), + radioIDUContinuityCheckLoss1plus0 (9798), + radioAccessModule1insertedbutnotenabled (9799), + radioAccessModule1insertedincorrectly (9800), + radioPS-1HighTemperatureAlarm (9801), + radioPS-2HighTemperatureAlarm (9802), + radioDeviceHighTemperatureAlarm (9803), + radioDeviceLowTemperatureAlarm (9804), + radioTransceiverTempHighAlarm (9805), + radioTransceiverTempLowAlarm (9806), + radioLAGmemberstateunknown (9807), + radioAccessModule2insertedbutnotenabled (9808), + radioAccessModule2insertedincorrectly (9809), + radioLPRemoteFailure (9810), + radioB1error (9811), + radioB2error (9812), + radioB3error (9813), + radioBIP-2error (9814), + radioLossofSequence (9815), + radioAlarmIndicationSignalAISIn (9816), + radioMaintenanceLoopback (9817), + radioPWFail (9818), + radioMemoryKeyNotPresent (9819), + radioMemoryKeyforWrongNEType (9820), + radioMemoryKeywithmismatchingcontent (9821), + radioCCMContinuityCheckLoss (9822), + radioOAMMAConfigurationError (9823), + radioSynchQualityLevelDegraded (9824), + radioSynchUnlockedPLL (9825), + radioPWFunctionAlarm (9826), + radioSpeedValuelowerthantheLimiteronthatinterface (9827), + radioSpeedValuelowerthanthesumofallCIR (9828), + radioServiceDownorServicePartial (9829), + radioAutonegotiationmismatch (9830), + radioRemoteFaultIndication (9831), + radioOvercurrent-undercurrentFPR (9832), + radioRemotePacketLoss (9833), + radioCCMPeerMEPStateDown (9834), + radioSynchMissingSSM (9835), + radioSynchConfigurationError (9836), + radioSynchOneSourceDown (9837), + radioSynchAllSourcesDown (9838), + radioAccountLogisfilledtothefirstthreshold (9839), + radioAccountLogisfilledtothesecondthreshold (9840), + radioSystemFailure (9841), + defect-id-vcxo-failure (9842), + tod-traceable-status (9843), + linkPortAStatus (9844), + linkPortBStatus (9845), + linkPortMStatus (9846), + fpgaStatus (9847), + peerTime (9848), + excessTraffic (9849), + excessClientLimit (9850), + squelchStatus (9851), + dcfMs (9852), + dcfRs (9853), + radioSFPmismatch (9854), + radioG8031ProtectionGroupFailed (9855), + radioSFPTemperatureAbnormal (9856), + radioSFPBIASCurrentAbnormal (9857), + radioSFPTxPowerAbnormal (9858), + radioSFPRxPowerAbnormal (9859), + eqp-critical-vcxo-failure (9860), + eqp-minor-vcxo-failure (9861), + eqp-critical-ocxo-failure (9862), + eqp-minor-ocxo-failure (9863), + lossOfSignalNPort (9864), + outputPowerFault (9865), + egptProvMismatch (9866), + autoShutdownAmpAps (9867), + processLockedOutSpeq (9868), + ppcLimitExceededSpeq (9869), + lossOfLaneOtu (9870), + lossOfMfiOpu (9871), + oosDisabledLckOduTrmt (9872), + configurationMismatch (9873), + oduAutoShutdownRxAIS (9874), + oduAutoShutdownTxAIS (9875), + oosDisabledLckOduRx (9876), + thres15MinExceededBbePcs (9877), + autoShutdownGAis (9878), + thres15MinExceededBbePcsRzs (9879), + alarmEquipmentMismatchAllowRzs (9880), + alarmWarmUpRzs (9881), + tellabsAlarmIndicationPanel (9882), + tellabsAGCoutOfGain (9883), + tellabsControlBusFailureJTAG (9884), + tellabsControlBusFailureIDSPI (9885), + tellabsControlBusFailureBCKPLNSPI (9886), + tellabsControlBusFailureTDM (9887), + tellabsControlBusFailureAIPSPI (9888), + tellabsControlandTimCommFail (9889), + tellabsLossSynchBetweenSpms (9890), + tellabsFansRunningHighSpeed (9891), + tellabsHoldoverSynchMode (9892), + tellabsIDPromFailure (9893), + tellabsMismatchofEquipment (9894), + tellabsMismatchofEquipmentHwVerMismatch (9895), + tellabsNetEquipmentInterconnectionFail (9896), + tellabsPowerFeedAProblem (9897), + tellabsPowerFeedA1Problem (9898), + tellabsPowerFeedBProblem (9899), + tellabsPowerFeedB1Problem (9900), + tellabsPowerORFilterProblem (9901), + tellabsReplaceableUnitMissing (9902), + tellabsReplaceableUnitProblemDeg (9903), + tellabsReplaceableUnitProblemFail (9904), + tellabsSwBootAbnormal (9905), + tellabsThermalProblem (9906), + ochOci (9907), + otuFecTypeMismatch (9908), + tellabsOpticalPowerTargetUnreachable (9909), + tellabsOpticalPowerOverload (9910), + msBersd (9911), + msBersf (9912), + msRfi (9913), + tellabsAggOutputPowerExceeded (9914), + tellabsAutoPowerMgmtProgress (9915), + overheadBdi (9916), + payloadBdi (9917), + oduBersd (9918), + otuBersd (9919), + tellabsCablePLos (9920), + tellabsCablePLosDwdmInterface (9921), + tellabsCablePLosExpressInterface (9922), + tellabsCablePLosMidStageAccess (9923), + tellabsCablePLosPortInterface (9924), + overheadFdi (9925), + payloadFdi (9926), + tellabsFiberMismatch (9927), + tellabsFacilityNotSupported (9928), + tellabsLosExpressInterface (9929), + tellabsFacilityLoopback (9930), + tellabsTerminalLoopback (9931), + payloadMissingIndication (9932), + tellabsProtectionNotAvailable (9933), + synchronizationReferenceFailure (9934), + tellabsProprietaryAis (9935), + freeRunningSynchMode (9936), + tellabsNoAirFilter (9937), + tellabsPowerFeedA2Problem (9938), + tellabsPowerFeedA3Problem (9939), + tellabsPowerFeedB2Problem (9940), + tellabsPowerFeedB3Problem (9941), + gfpClientSignalFailFdi (9942), + gfpClientSignalFailRdi (9943), + remoteFault (9944), + tellabsFabricDegrade (9945), + tellabsFabricFailure (9946), + cSFOPU (9947), + aISL (9948), + bERSDL (9949), + bERSFL (9950), + rFIL (9951), + tIMR (9952), + mgmtEthLinkDown (9953), + alarmIndSig (9954), + freqOff (9955), + adjacencyLost (9956), + cableLosPrevious (9957), + cableLosNext (9958), + confFail (9959), + degrade (9960), + failure (9961), + gtwyUnreachable (9962), + mgmtRestricted (9963), + misWired (9964), + misMatched (9965), + dhcpNoIPAddr (9966), + dhcpOutOfIPAddr (9967), + dupIPAddr (9968), + dupIPAddrNet (9969), + ntpPeerUnreachable (9970), + progflt (9971), + cabs (9972), + swPatch (9973), + swUpgrade (9974), + swUpgradeWait (9975), + dccerr (9976), + dhcpRelayFail (9977), + dlCEFCompleted (9978), + patchDwCompleted (9979), + installCEFCompleted (9980), + installCEFFail (9981), + installCEFProgress (9982), + patchApplyProgress (9983), + patchApplyFail (9984), + patchApplyCompleted (9985), + securityLogRollOver (9986), + softwareDownloadCompleted (9987), + softwareInstallProgress (9988), + softwareInstallFail (9989), + softwareInstallCompleted (9990), + softwareExecProgress (9991), + softwareExecFail (9992), + softwareExecCompleted (9993), + softwarePatchAbort (9994), + softwareUpgradeAbort (9995), + inactive (9996), + intrusion (9997), + userlock (9998), + genericAIS (9999), + sdCardMissing (10000), + sdCardFailure (10001), + thresholdOCTETS15 (10002), + thresholdOCTETS24 (10003), + thresholdOPTHT15 (10004), + thresholdOPTHT24 (10005), + thresholdOPTLT15 (10006), + thresholdOPTLT24 (10007), + thresholdPDLHT15 (10008), + thresholdPDLHT24 (10009), + thresholdPKTS1024TO1518OCTETS15 (10010), + thresholdPKTS1024TO1518OCTETS24 (10011), + thresholdPKTS128TO255OCTETS15 (10012), + thresholdPKTS128TO255OCTETS24 (10013), + thresholdPKTS256TO511OCTETS15 (10014), + thresholdPKTS256TO511OCTETS24 (10015), + thresholdPKTS512TO1023OCTETS15 (10016), + thresholdPKTS512TO1023OCTETS24 (10017), + thresholdPKTS64OCTETS15 (10018), + thresholdPKTS64OCTETS24 (10019), + thresholdPKTS65TO127OCTETS15 (10020), + thresholdPKTS65TO127OCTETS24 (10021), + thresholdQFACTORLT15 (10022), + thresholdQFACTORLT24 (10023), + latchTriggered (10024), + thresholdOFTHT15 (10051), + thresholdOFTHT24 (10052), + thresholdOFTLT15 (10053), + thresholdOFTLT24 (10054), + thresholdOFRHT15 (10055), + thresholdOFRHT24 (10056), + thresholdOFRLT15 (10057), + thresholdOFRLT24 (10058), + pumpsOff (10059), + aSELos (10060), + aRPPause (10061) + } + + + +TrafficDirection ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION " Traffic direction affected by an alarm. " + SYNTAX INTEGER + { + unknown(0), + none(1), + inbound(2), + outbound(3), + both(4), + outboundClientToLine(5), + outboundLineToClient(6) + } + + + + +Directionality ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Direction of a resource." + SYNTAX INTEGER + { + unknown(1), + unidirectional(2), + bidirectional(3) + } + +NEClass ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Class of an NE." + SYNTAX INTEGER + { + singleNode(1), + repeaterNode(2), + managementNode(3), + masterRingNode(4), + slaveRingNode(5) + } + +PTTechnology ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Technology of a port. This value is an integer whose bits are mapped as follows: +- bit 0 (value 1): PDH +- bit 1 (value 2): SDH +- bit 2 (value 4): ATM +- bit 3 (value 8): WDM +- bit 4 (value 16): Ethernet +- bit 5 (value 32): OTH +- bit 6 (value 64): Data +- bit 7 (value 128): Generic" + SYNTAX Integer32 + +PTServiceType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Service type of a port. The value is an integer whose bits are mapped as follows: +- bit 0 (value 1): Obsolete +- bit 1 (value 2): The port supports bundle SNCs +- bit 2 (value 4): The port may not be connected to other ports +- bit 3 (value 8): The port does not support unidirectional SNCs +- bit 4 (value 16): The port does not support flexible SNCs" + SYNTAX Integer32 + +PTInterfaceType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Type of interface medium." + SYNTAX INTEGER + { + unknown(0), + optical(1), + electrical(2), + radio(3) + } + +PTProtectionType::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Protection type of a port." + SYNTAX INTEGER + { + unprotected(0), -- No MS Protection + msLtpWorking(1), -- working port in an MS-LTP + msLtpWorkingExtra(2), -- working port in an MS-LTP with extra traffic + msLtpProtecting(3) , -- protecting port in an MS-LTP + msLtpProtectingExtra(4), -- protecting port in an MS-LTP with extra traffic + bshr2East(5), -- east port in a 2-fibre BSHR + bshr2EastExtra(6), -- east port in a 2-fibre BSHR with extra traffic + bshr2West(7), -- west port in a 2-fibre BSHR + bshr2WestExtra(8), -- west port in a 2-fibre BSHR with extra traffic + bshr4EastWorking(9), -- east working port in a 4-fibre BSHR + bshr4EastProtecting(10), -- east protecting port in a 4-fibre BSHR + bshr4WestWorking(11), -- west working port in a 4-fibre BSHR + bshr4WestProtecting(12), -- west protecting port in a 4-fibre BSHR + bshr4TransoceanicEastWorking(13), -- east working port in a Transoceanic 4-fibre BSHR + bshr4TransoceanicEastProtecting(14),-- east protecting port in a Transoceanic 4-fibre BSHR + bshr4TransoceanicWestWorking(15), -- west working port in a Transoceanic 4-fibre BSHR + bshr4TransoceanicWestProtecting(16) -- west protecting port in a Transoceanic 4-fibre BSHR +} + +TPType ::= TEXTUAL-CONVENTION + STATUS obsolete + DESCRIPTION "Termination point type. Obsolete." + SYNTAX INTEGER + { + unknown(1), + variable(2), + fixed(3) + } + +TPTerminationType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Termination type of a TP." + SYNTAX INTEGER + { + connection(1), -- CTP + trail(2) -- TTP + } + +TPReliability ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Reliability of a TP: +- preEmptive - The resource is rather unreliable and will only be used for low priority services, as long it is not needed to protect high priority services. +- unprotected - The resource is not protected by MSP +- protected: The resource is protected by MSP +" + SYNTAX INTEGER + { + preEmptive(1), + unprotected(2), + protected(3) + } + +SVProtection ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Service protection. Not used." + SYNTAX INTEGER + { + unprotected(1), + prEnd2End(2), + prInSubnetworks(3), + prInAndBetweenSubnetworks(4) + } + +SNCProtectionInfo ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Describes how SNC is protected: + - unprotected: Only 1 source and 1 destination TPs + - simpleProtectionInfo: Protection with at most 2 source and 2 destination TPs + - extendedProtectionInfo: Protection with more than 2 source or 2 destinations TPs" + SYNTAX INTEGER + { + unprotected(1), + simpleProtectionInfo(2), + extendedProtectionInfo(3) + } + + +EthernetPathProtectionInfo ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Describes how Ethernet Path is protected: + - TODO" + SYNTAX INTEGER + { + unknown(0), + unprotected(1), + oneToOne(2), + lspOneToOne(3), + ring(4) + } + +EthernetPathType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Describes how Ethernet Path is protected: + - TODO" + SYNTAX INTEGER + { + pointToPoint(1), + multipointToMultipoint(2), + rootedMultipoint(3) + } + + +TPEndPointType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Indicates whether the TP has the role of a A-end TP (source TP) or a Z-end TP (destination TP) in a SNC." + SYNTAX INTEGER + { + sourceTP(1), + destinationTP(2) + } + +TPTimeSlotHierarchy ::= TEXTUAL-CONVENTION + STATUS obsolete + DESCRIPTION "Obsolete." + SYNTAX OCTET STRING (SIZE (13..29)) + +CharacteristicInfo ::= TEXTUAL-CONVENTION + STATUS obsolete + DESCRIPTION "Obsolete." + SYNTAX INTEGER + { + unknown(1) + } + +NotificationType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Type of notification in the history table." + SYNTAX INTEGER + { + other(0), + objectCreation(1), + objectDeletion(2), + stateChange(3), + attributeValueChange(4), + alarm(5), + relationshipChange(6) + } + +LayerSet ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Character string with one or more transport layers (e.g. VC4, OTU1) separated by commas." + + SYNTAX OCTET STRING (SIZE (0..255)) + + + +FilterType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Type of object for which to collect data." + SYNTAX INTEGER + { + unknown(0), + tpObject(1), + portObject(2), + neObject(3), + sncObject(4), + ethernetPathObject(5) + } + + + +-- ---------------------------------- +-- PerfMon Enumerated values +-- ---------------------------------- + +PerfMonRequestId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a PerfMon request." + SYNTAX UniqueId + + +PerfMonRequestState ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "State of a PerfMon request." + SYNTAX INTEGER + { + unknown(0), + created(1), + pending(2), + started(3), + finished(4), + failed(5), + cancelling(6), + cancelled(7), + deleting(8) + } + + +PerfMonType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Type of PM data." + SYNTAX INTEGER + { + unknown(0), + pmHistory(1), + pmCurrent(2), + pmPoints(3) + } + + +PerfMonGranularity ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Granularity of PM data." + SYNTAX INTEGER + { + unknown(0), + minutes15(1), + hours24(2) + } + + + +PerfMonLocation ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "PMP location." + SYNTAX INTEGER + { + unknown(0), + nearEnd(1), + farEnd(2) + } + + +PerfMonDirection ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "PMP direction." + SYNTAX INTEGER + { + unknown(0), + none(1), + incoming(2), + outgoing(3), + both(4) + } + + +PerfMonStatus ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Status of the PM parameter value." + SYNTAX INTEGER + { + unknown(0), + valid(1), + invalid(2), + incomplete(3) + } + + +PerfMonThresholdType ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Type of PM threshold." + SYNTAX INTEGER + { + unknown(0), + lowest(1), + low(2), + high(3), + highest(4) + } + + + +-- ---------------------------------- +-- OptPowerMon Enumerated values +-- ---------------------------------- + +OptPowerMonRequestId ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "Global identifier of a OptPowerMon request." + SYNTAX UniqueId + + +OptPowerMonRequestState ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION "State of a OptPowerMon request." + SYNTAX INTEGER + { + unknown(0), + created(1), + pending(2), + started(3), + finished(4), + failed(5), + cancelling(6), + cancelled(7), + deleting(8) + } + + + +-- -------------------------------------------------------------------------- +-- -------------------------------------------------------------------------- + + +enmsNetworkSetup OBJECT IDENTIFIER ::= { svsProxEnms 1 } + +enmsService OBJECT IDENTIFIER ::= { svsProxEnms 2 } + +enmsAlarmTables OBJECT IDENTIFIER ::= { svsProxEnms 3 } + +enmsProxy OBJECT IDENTIFIER ::= { svsProxEnms 4 } + +enmsTrapGroup OBJECT IDENTIFIER ::= { svsProxEnms 5 } + +enmsPerfMon OBJECT IDENTIFIER ::= { svsProxEnms 6 } + +enmsOptPowerMon OBJECT IDENTIFIER ::= { svsProxEnms 7 } + +enmsCounter OBJECT IDENTIFIER ::= { enmsProxy 1 } + +enmsControl OBJECT IDENTIFIER ::= { enmsProxy 2 } + +enmsTrapHist OBJECT IDENTIFIER ::= { enmsTrapGroup 1 } + +enmsTrapVariable OBJECT IDENTIFIER ::= { enmsTrapGroup 2 } + +enmsTraps OBJECT IDENTIFIER ::= { enmsTrapGroup 3 } + +enmsTrapFilter OBJECT IDENTIFIER ::= { enmsTrapGroup 4 } + + + +-- -------------------------------------------------------------------------- +-- +-- Network Topology +-- +-- -------------------------------------------------------------------------- + + +-- -------------------------------------------------------------------------- +-- Network Element Table (NE's) +-- -------------------------------------------------------------------------- + +enmsNETable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsNEEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all NEs in the network." + ::= { enmsNetworkSetup 1 } + +enmsNEEntry OBJECT-TYPE + SYNTAX EnmsNEEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the NE table." + INDEX { enmsNeNEId } + ::= { enmsNETable 1 } + +EnmsNEEntry ::= SEQUENCE + { + enmsNeNEId NEId, + enmsNeType DisplayString, + enmsNeName DisplayString, + enmsNeLocation DisplayString, + enmsNeAlarmSeverity PerceivedSeverity, + enmsNeOperatingMode OperatingMode, + enmsNeOpState OperationalState, + enmsNeCanBroadcast Boolean, + enmsNeCanPathProtection Boolean, + enmsNeClass NEClass, + enmsNeExternalNEId InfoString, -- obsolete + enmsNeIsPseudoNE Boolean, + enmsNeIdName DisplayString, + enmsNeCommunicationState OperationalState, + enmsNeDCNLocation DisplayString, + enmsNeSystemContainer DisplayString, + enmsNeUserText DisplayString + } + +enmsNeNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Global NE identifier (table index)." + ::= { enmsNEEntry 1 } + +enmsNeType OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE type." + ::= { enmsNEEntry 2 } + +enmsNeName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE name, as reported by the NE." + ::= { enmsNEEntry 3 } + +enmsNeLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location in the network map (topology container)." + ::= { enmsNEEntry 4 } + +enmsNeAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest severity of all alarms affecting the NE or its + modules, ports and TPs." + ::= { enmsNEEntry 5 } + +enmsNeOperatingMode OBJECT-TYPE + SYNTAX OperatingMode + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE's ability to send notifications: + Operation: The NE reports all events to TNMS normally; + Maintenance: The NE is suppressing all notifications (typically + for maintenance purposes, to prevent heavy DCN load)." + ::= { enmsNEEntry 6 } + +enmsNeOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE operational state." + ::= { enmsNEEntry 7 } + +enmsNeCanBroadcast OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates if at least one port has broadcast capabilities." + ::= { enmsNEEntry 8 } + +enmsNeCanPathProtection OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates if at least one port has protection capabilities (SNCP)." + ::= { enmsNEEntry 9 } + +enmsNeClass OBJECT-TYPE + SYNTAX NEClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE class. Unsupported." + ::= { enmsNEEntry 10 } + +enmsNeExternalNEId OBJECT-TYPE + SYNTAX InfoString + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsNEEntry 11 } + +enmsNeIsPseudoNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Obsolete." + ::= { enmsNEEntry 12 } + +enmsNeIdName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE name, as specified by the operator in TNMS." + ::= { enmsNEEntry 13 } + +enmsNeCommunicationState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Communication state of the NE" + ::= { enmsNEEntry 14 } + +enmsNeDCNLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Path to the NE in the DCN tree." + ::= { enmsNEEntry 15 } + +enmsNeSystemContainer OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE System name." + ::= { enmsNEEntry 16 } + +enmsNeUserText OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "The UserText value as configured in the DCN property page of the NE." + ::= { enmsNEEntry 17 } + +-- -------------------------------------------------------------------------- +-- Module Table +-- -------------------------------------------------------------------------- + +enmsModuleTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsModuleEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all modules in the network." + ::= { enmsNetworkSetup 2 } + +enmsModuleEntry OBJECT-TYPE + SYNTAX EnmsModuleEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the Module table." + INDEX { enmsMoNEId, enmsMoModuleId } + ::= { enmsModuleTable 1 } + +EnmsModuleEntry ::= SEQUENCE + { + enmsMoNEId NEId, + enmsMoModuleId ModuleId, + enmsMoType DisplayString, -- obsolete + enmsMoName DisplayString, + enmsMoOpState OperationalState, + enmsMoShelf DisplayString, + enmsMoSlot DisplayString, + enmsMoObjectType Integer32 + } + +enmsMoNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Identifier (table index)." + ::= { enmsModuleEntry 1 } + +enmsMoModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Module identifier within the NE (table index)." + ::= { enmsModuleEntry 2 } + +enmsMoType OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Type of module." + ::= { enmsModuleEntry 3 } + +enmsMoName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Module name." + ::= { enmsModuleEntry 4 } + +enmsMoOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state of the module." + ::= { enmsModuleEntry 5 } + +enmsMoShelf OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Shelf of the module, preceded by the rack number, if applicable. + Example: 02-005" + ::= { enmsModuleEntry 6 } + +enmsMoSlot OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Slot number of the module. If present, the sub-slot is + appended, separated by a dot." + ::= { enmsModuleEntry 7 } + +enmsMoObjectType OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Object Type ID." + ::= { enmsModuleEntry 8 } + +-- -------------------------------------------------------------------------- +-- Port Table +-- -------------------------------------------------------------------------- + +enmsPortTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsPortEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all ports in the network." + ::= { enmsNetworkSetup 3 } + +enmsPortEntry OBJECT-TYPE + SYNTAX EnmsPortEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the port table." + INDEX { enmsPtNEId,enmsPtPortId } + ::= { enmsPortTable 1 } + +EnmsPortEntry ::= SEQUENCE + { + enmsPtNEId NEId, + enmsPtPortId PortId, + enmsPtName DisplayString, + enmsPtModuleId ModuleId, -- obsolete + enmsPtTechnology PTTechnology, + enmsPtServiceType PTServiceType, + enmsPtInterfaceType PTInterfaceType, + enmsPtBandwidth Bandwidth, + enmsPtOpState OperationalState, -- obsolete + enmsPtOperatingMode OperatingMode, -- obsolete + enmsPtDirection Directionality, + enmsPtCanBroadcast Boolean, + enmsPtCanPathProtection Boolean, + enmsPtAlarmSeverity PerceivedSeverity, + enmsPtAdminState AdministrativeState, -- obsolete + enmsPtOpStateTX OperationalState, + enmsPtOpStateRX OperationalState, + enmsPtModuleIdTX ModuleId, + enmsPtModuleIdRX ModuleId, + enmsPtLayerSet LayerSet, + enmsPtProtectionType PTProtectionType, + enmsPtObjectType Integer32 + } + +enmsPtNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE identifier (table index)." + ::= { enmsPortEntry 1 } + +enmsPtPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port dentifier within the NE (table index)." + ::= { enmsPortEntry 2 } + +enmsPtName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port name." + ::= { enmsPortEntry 3 } + +enmsPtModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete. See enmsPtModuleIdTX/enmsPtModuleIdRX." + ::= { enmsPortEntry 4 } + +enmsPtTechnology OBJECT-TYPE + SYNTAX PTTechnology + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Transport technology." + ::= { enmsPortEntry 5 } + +enmsPtServiceType OBJECT-TYPE + SYNTAX PTServiceType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Supported service types." + ::= { enmsPortEntry 6 } + +enmsPtInterfaceType OBJECT-TYPE + SYNTAX PTInterfaceType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of interface." + ::= { enmsPortEntry 7 } + +enmsPtBandwidth OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Bandwidth of the port." + ::= { enmsPortEntry 8 } + +enmsPtOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete. Set to 'enabled' if enmsPtOpStateTX and + enmsPtOpStateRX are both enabled, else 'disabled'." + ::= { enmsPortEntry 9 } + +enmsPtOperatingMode OBJECT-TYPE + SYNTAX OperatingMode + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsPortEntry 10 } + +enmsPtDirection OBJECT-TYPE + SYNTAX Directionality + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port direction." + ::= { enmsPortEntry 11 } + +enmsPtCanBroadcast OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates if the port has broadcast capabilities." + ::= { enmsPortEntry 12 } + +enmsPtCanPathProtection OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates if the port has protection capabilities (SNCP)." + ::= { enmsPortEntry 13 } + +enmsPtAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest severity of all alarms affecting the port or its TPs." + ::= { enmsPortEntry 14 } + +enmsPtAdminState OBJECT-TYPE + SYNTAX AdministrativeState + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsPortEntry 15 } + +enmsPtOpStateTX OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state in TX direction." + ::= { enmsPortEntry 16 } + +enmsPtOpStateRX OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state in RX direction." + ::= { enmsPortEntry 17 } + +enmsPtModuleIdTX OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Module ID for TX direction." + ::= { enmsPortEntry 18 } + +enmsPtModuleIdRX OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Module ID for RX direction." + ::= { enmsPortEntry 19 } + +enmsPtLayerSet OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Terminated layers." + ::= { enmsPortEntry 20 } + +enmsPtProtectionType OBJECT-TYPE + SYNTAX PTProtectionType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Protection type." + ::= { enmsPortEntry 21 } + +enmsPtObjectType OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Object Type ID. " + ::= { enmsPortEntry 22 } + +-- -------------------------------------------------------------------------- +-- Termination Point Table +-- -------------------------------------------------------------------------- + +enmsTPTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsTPEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all termination points in the network." + ::= { enmsNetworkSetup 4 } + +enmsTPEntry OBJECT-TYPE + SYNTAX EnmsTPEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the TP table." + INDEX { enmsTpNEId,enmsTpPortId,enmsTpTPIdH,enmsTpTPIdL } + ::= { enmsTPTable 1 } + +EnmsTPEntry ::= SEQUENCE + { + enmsTpNEId NEId, + enmsTpPortId PortId, + enmsTpTPIdH TPId, + enmsTpTPIdL TPId, + enmsTpTPIndex TPIndex, + enmsTpNxCount Integer32, + enmsTpName DisplayString, + enmsTpBandwidth Bandwidth, + enmsTpTPType TPType, -- obsolete + enmsTpTerminType TPTerminationType, + enmsTpDirection Directionality, + enmsTpOpStateTX OperationalState, + enmsTpOpStateRX OperationalState, + enmsTpAlarmSeverity PerceivedSeverity, + enmsTpAdminState AdministrativeState, -- obsolete + enmsTpUsageCountTX Integer32, + enmsTpUsageCountRX Integer32, + enmsTpUsageStateTX UsageState, + enmsTpUsageStateRX UsageState, + enmsTpReliability TPReliability, -- obsolete + enmsTpLayerSet LayerSet, + enmsTpBandwidthTX Bandwidth, + enmsTpBandwidthRX Bandwidth, + enmsTpParentPortId PortId, + enmsTpParentTPIdH TPId, + enmsTpParentTPIdL TPId, + enmsTpFragmentLayer LayerSet, + enmsTpObjectType Integer32, + enmsTpMuxPartnerTPIdH TPId, + enmsTpMuxPartnerTPIdL TPId + } + +enmsTpNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id (table index)." + ::= { enmsTPEntry 1 } + +enmsTpPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id (table index)." + ::= { enmsTPEntry 2 } + +enmsTpTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id (table index)." + ::= { enmsTPEntry 3 } + +enmsTpTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id (table index)." + ::= { enmsTPEntry 4 } + +enmsTpTPIndex OBJECT-TYPE + SYNTAX TPIndex + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "TP index relative to the port (might be a timeslot index)." + ::= { enmsTPEntry 5 } + +enmsTpNxCount OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Inverse multiplexing number in case the TP represents a + virtual concatenated group. Otherwise, value is 1." + ::= { enmsTPEntry 6 } + +enmsTpName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "TP name." + ::= { enmsTPEntry 7 } + +enmsTpBandwidth OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "TP bandwidth." + ::= { enmsTPEntry 8 } + +enmsTpTPType OBJECT-TYPE + SYNTAX TPType + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsTPEntry 9 } + +enmsTpTerminType OBJECT-TYPE + SYNTAX TPTerminationType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Termination type (TTP or CTP)." + ::= { enmsTPEntry 10 } + +enmsTpDirection OBJECT-TYPE + SYNTAX Directionality + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "TP direction." + ::= { enmsTPEntry 11 } + +enmsTpOpStateTX OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state in TX direction." + ::= { enmsTPEntry 12 } + +enmsTpOpStateRX OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state in RX direction." + ::= { enmsTPEntry 13 } + +enmsTpAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest severity of all alarms affecting the TPs." + ::= { enmsTPEntry 14 } + +enmsTpAdminState OBJECT-TYPE + SYNTAX AdministrativeState + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsTPEntry 15 } + +enmsTpUsageCountTX OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of cross connections using the TP for the TX + direction. Unsupported." + ::= { enmsTPEntry 16 } + +enmsTpUsageCountRX OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of cross connections using the TP for the RX + direction. Unsupported." + ::= { enmsTPEntry 17 } + +enmsTpUsageStateTX OBJECT-TYPE + SYNTAX UsageState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Usage state in the TX direction. Unsupported." + ::= { enmsTPEntry 18 } + +enmsTpUsageStateRX OBJECT-TYPE + SYNTAX UsageState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Usage state in the RX direction. Unsupported." + ::= { enmsTPEntry 19 } + +enmsTpReliability OBJECT-TYPE + SYNTAX TPReliability + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsTPEntry 20 } + +enmsTpLayerSet OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "TP transport layer set." + ::= { enmsTPEntry 21 } + +enmsTpBandwidthTX OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "TP bandwidth in the TX direction. Unsupported." + ::= { enmsTPEntry 22 } + +enmsTpBandwidthRX OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "TP bandwidth in the RX direction. Unsupported." + ::= { enmsTPEntry 23 } + +enmsTpParentPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of parent TP (if applicable)." + ::= { enmsTPEntry 24 } + +enmsTpParentTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of parent TP (if applicable)." + ::= { enmsTPEntry 25 } + +enmsTpParentTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of parent TP (if applicable)." + ::= { enmsTPEntry 26 } + +enmsTpFragmentLayer OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Fragment layer set in case the TP represents a VC group." + ::= { enmsTPEntry 27 } + +enmsTpObjectType OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Object Type ID." + ::= { enmsTPEntry 28 } + +enmsTpMuxPartnerTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of multiplex partner TP (if applicable)." + ::= { enmsTPEntry 29 } + +enmsTpMuxPartnerTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of multiplex partner TP (if applicable)." + ::= { enmsTPEntry 30 } + +-- -------------------------------------------------------------------------- +-- Port Connection Table +-- -------------------------------------------------------------------------- + +enmsPortConnTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsPortConnEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all managed ports connections (physical links)." + ::= { enmsNetworkSetup 5 } + +enmsPortConnEntry OBJECT-TYPE + SYNTAX EnmsPortConnEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the Port Connection table." + INDEX { enmsPcPortConnId } + ::= { enmsPortConnTable 1 } + +EnmsPortConnEntry ::= SEQUENCE + { + enmsPcPortConnId PortConnId, + enmsPcSrcNEId NEId, + enmsPcSrcPortId PortId, + enmsPcDstNEId NEId, + enmsPcDstPortId PortId, + enmsPcName DisplayString, + enmsPcSrcAlarmSeverity PerceivedSeverity, + enmsPcDstAlarmSeverity PerceivedSeverity, + enmsPcBandwidth Bandwidth, + enmsPcDirection Directionality, + enmsPcLayerSet LayerSet + } + +enmsPcPortConnId OBJECT-TYPE + SYNTAX PortConnId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Connection identifier (table index)." + ::= { enmsPortConnEntry 1 } + +enmsPcSrcNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of source port." + ::= { enmsPortConnEntry 2 } + +enmsPcSrcPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of source port." + ::= { enmsPortConnEntry 3 } + +enmsPcDstNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of destination port." + ::= { enmsPortConnEntry 4 } + +enmsPcDstPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of destination port." + ::= { enmsPortConnEntry 5 } + +enmsPcName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port connection name." + ::= { enmsPortConnEntry 6 } + +enmsPcSrcAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest severity of all alarms affecting the source + port or module." + ::= { enmsPortConnEntry 7 } + +enmsPcDstAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest severity of all alarms affecting the destination + port or module." + ::= { enmsPortConnEntry 8 } + +enmsPcBandwidth OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port connection bandwidth." + ::= { enmsPortConnEntry 9 } + +enmsPcDirection OBJECT-TYPE + SYNTAX Directionality + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port connection direction." + ::= { enmsPortConnEntry 10 } + +enmsPcLayerSet OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port connection layer set." + ::= { enmsPortConnEntry 11 } + + +-- -------------------------------------------------------------------------- +-- Subnetwork Connection Table +-- -------------------------------------------------------------------------- + +enmsSNCTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all paths of the Optical Manager." + ::= { enmsNetworkSetup 6 } + +enmsSNCEntry OBJECT-TYPE + SYNTAX EnmsSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the SNC table." + INDEX { enmsScSNCId } + ::= { enmsSNCTable 1 } + +EnmsSNCEntry ::= SEQUENCE + { + enmsScSNCId SNCId, + enmsScSrcNEId NEId, + enmsScSrcPortId PortId, + enmsScSrcTPIdH TPId, + enmsScSrcTPIdL TPId, + enmsScDestNEId NEId, + enmsScDestPortId PortId, + enmsScDestTPIdH TPId, + enmsScDestTPIdL TPId, + enmsScSrc2NEId NEId, + enmsScSrc2PortId PortId, + enmsScSrc2TPIdH TPId, + enmsScSrc2TPIdL TPId, + enmsScDest2NEId NEId, + enmsScDest2PortId PortId, + enmsScDest2TPIdH TPId, + enmsScDest2TPIdL TPId, + enmsScServiceId ServiceId, + enmsScName DisplayString, + enmsScOpState OperationalState, + enmsScAdminState AdministrativeState, + enmsScAlarmSeverity PerceivedSeverity, + enmsScBandwidth Bandwidth, + enmsScDirection Directionality, + enmsScProtectionFlag Boolean, -- obsolete + enmsScProtectionInfo SNCProtectionInfo, + enmsScNxCount Unsigned32, + enmsScSNCOwnerId SNCId, + enmsScLayerSet LayerSet, + enmsScFragmentLayer LayerSet, + enmsScMinBandwidth Bandwidth, + enmsScRequiredBandwidth Boolean + } + +enmsScSNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "SNC Id (table index)." + ::= { enmsSNCEntry 1 } + +enmsScSrcNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the first A-end in the list of path edges." + ::= { enmsSNCEntry 2 } + +enmsScSrcPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the first A-end in the list of path edges." + ::= { enmsSNCEntry 3 } + +enmsScSrcTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of the first A-end in the list + of path edges." + ::= { enmsSNCEntry 4 } + +enmsScSrcTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of the first A-end in the list + of path edges." + ::= { enmsSNCEntry 5 } + +enmsScDestNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Ne Id of the first Z-end in the list of path edges." + ::= { enmsSNCEntry 6 } + +enmsScDestPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the first Z-end in the list of path edges." + ::= { enmsSNCEntry 7 } + +enmsScDestTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of the first Z-end in the list + of path edges." + ::= { enmsSNCEntry 8 } + +enmsScDestTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of the first Z-end in the list + of path edges." + ::= { enmsSNCEntry 9 } + +enmsScSrc2NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Ne Id of the second A-end in the list of path edges." + ::= { enmsSNCEntry 10 } + +enmsScSrc2PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the second A-end in the list of path edges." + ::= { enmsSNCEntry 11 } + +enmsScSrc2TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of the second A-end in the list + of path edges." + ::= { enmsSNCEntry 12 } + +enmsScSrc2TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of the second A-end in the list + of path edges." + ::= { enmsSNCEntry 13 } + +enmsScDest2NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Ne Id of the second Z-end in the list of path edges." + ::= { enmsSNCEntry 14 } + +enmsScDest2PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the second Z-end in the list of path edges." + ::= { enmsSNCEntry 15 } + +enmsScDest2TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of the second Z-end in the list of + path edges." + ::= { enmsSNCEntry 16 } + +enmsScDest2TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of the second Z-end in the list + of path edges." + ::= { enmsSNCEntry 17 } + +enmsScServiceId OBJECT-TYPE + SYNTAX ServiceId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsSNCEntry 18 } + +enmsScName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Name as presented in the TNMS GUI." + ::= { enmsSNCEntry 19 } + +enmsScOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state. Set to 'enabled' if and only if + in TNMS the ACS is 'Active' and the Operational + State is 'Enabled'." + ::= { enmsSNCEntry 20 } + +enmsScAdminState OBJECT-TYPE + SYNTAX AdministrativeState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Administrative state. This value reflects the RCS + of the path: 'unlocked' if RCS is 'Active', + otherwise 'locked'." + ::= { enmsSNCEntry 21 } + +enmsScAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest severity of all alarms affecting this SNC. + Unsupported." + ::= { enmsSNCEntry 22 } + +enmsScBandwidth OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "SNC bandwidth." + ::= { enmsSNCEntry 23 } + +enmsScDirection OBJECT-TYPE + SYNTAX Directionality + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "SNC direction." + ::= { enmsSNCEntry 24 } + +enmsScProtectionFlag OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsSNCEntry 25 } + +enmsScProtectionInfo OBJECT-TYPE + SYNTAX SNCProtectionInfo + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Describes how SNC is protected." + ::= { enmsSNCEntry 26 } + +enmsScNxCount OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "The inverse multiplexing number, in case the SNC represents + a virtual concatenated group." + ::= { enmsSNCEntry 27 } + +enmsScSNCOwnerId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsSNCEntry 28 } + +enmsScLayerSet OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Layer set of the SNC." + ::= { enmsSNCEntry 29 } + +enmsScFragmentLayer OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "The layer of the fragments, in case the SNC represents a + virtual concatenated group." + ::= { enmsSNCEntry 30 } + +enmsScMinBandwidth OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Minimum actual or required bandwidth of all edges of the + SNC connection topology." + ::= { enmsSNCEntry 31 } + +enmsScRequiredBandwidth OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the value of the attribute Bandwidth is + required (explicitly assigned by the operator)." + ::= { enmsSNCEntry 32 } + + +-- -------------------------------------------------------------------------- +-- Subnetwork Connection TP Table +-- -------------------------------------------------------------------------- + +enmsSNCTPTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsSNCTPEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "SNC-TP table. Unsupported." + ::= { enmsNetworkSetup 7 } + +enmsSNCTPEntry OBJECT-TYPE + SYNTAX EnmsSNCTPEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Entry of the subnetwork connection tp table. " + INDEX { enmsStSNCId, enmsStTPNumber } + ::= { enmsSNCTPTable 1 } + +EnmsSNCTPEntry ::= SEQUENCE + { + enmsStSNCId SNCId, + enmsStTPNumber Unsigned32, + enmsStNEId NEId, + enmsStPortId PortId, + enmsStTPIdH TPId, + enmsStTPIdL TPId, + enmsStIsWorkingTP Boolean, -- obsolete + enmsStEndPointType TPEndPointType, + enmsStTimeSlotHry TPTimeSlotHierarchy -- obsolete + } + +enmsStSNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " SNC number used as first table index. Mandatory. " + ::= { enmsSNCTPEntry 1 } + +enmsStTPNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Number of the TP, second table index. Mandatory. " + ::= { enmsSNCTPEntry 2 } + +enmsStNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NEId of the TP. Mandatory. " + ::= { enmsSNCTPEntry 3 } + +enmsStPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Port number of the TP. Mandatory. " + ::= { enmsSNCTPEntry 4 } + +enmsStTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP ID (high dw) of the TP. Mandatory. " + ::= { enmsSNCTPEntry 5 } + +enmsStTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP ID (low dw) of the TP. Mandatory. " + ::= { enmsSNCTPEntry 6 } + +enmsStIsWorkingTP OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. fix value: false. " + ::= { enmsSNCTPEntry 7 } + +enmsStEndPointType OBJECT-TYPE + SYNTAX TPEndPointType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Information, whether this TP is source or destination TP. Mandatory. " + ::= { enmsSNCTPEntry 8 } + +enmsStTimeSlotHry OBJECT-TYPE + SYNTAX TPTimeSlotHierarchy + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "obsolete, never supported. fix value: empty String, even though size is 13..29. " + ::= { enmsSNCTPEntry 9 } + + +-- -------------------------------------------------------------------------- +-- SNC TPHierarchie Table +-- -------------------------------------------------------------------------- + +enmsSNCTHTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsSNCTHEntry + MAX-ACCESS not-accessible + STATUS obsolete + DESCRIPTION + "Obsolete table." + ::= { enmsNetworkSetup 8 } + +enmsSNCTHEntry OBJECT-TYPE + SYNTAX EnmsSNCTHEntry + MAX-ACCESS not-accessible + STATUS obsolete + DESCRIPTION + " obsolete. never used. " + INDEX { enmsThSNCId, enmsThTPNumber, enmsThTPHierId } + ::= { enmsSNCTHTable 1 } + +EnmsSNCTHEntry ::= SEQUENCE -- The whole table is obsolete + { + enmsThSNCId SNCId, -- obsolete + enmsThTPNumber Unsigned32, -- obsolete + enmsThTPHierId CharacteristicInfo, -- obsolete + enmsThChannelNo Unsigned32 -- obsolete + } + +enmsThSNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. never used. " + ::= { enmsSNCTHEntry 1 } + +enmsThTPNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. never used. " + ::= { enmsSNCTHEntry 2 } + +enmsThTPHierId OBJECT-TYPE + SYNTAX CharacteristicInfo + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. never used. " + ::= { enmsSNCTHEntry 3 } + +enmsThChannelNo OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. never used. " + ::= { enmsSNCTHEntry 4 } + + +-- -------------------------------------------------------------------------- +-- Cross Connection Table +-- -------------------------------------------------------------------------- + +enmsCCTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsCCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all cross connections in the network." + ::= { enmsNetworkSetup 9 } + +enmsCCEntry OBJECT-TYPE + SYNTAX EnmsCCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the cross connection table." + INDEX { enmsCcNEId, enmsCcCCId } + ::= { enmsCCTable 1 } + +EnmsCCEntry ::= SEQUENCE + { + enmsCcNEId NEId, + enmsCcCCId CCId, + enmsCcSrcNEId NEId, + enmsCcSrcPortId PortId, + enmsCcSrcTPIdH TPId, + enmsCcSrcTPIdL TPId, + enmsCcDestNEId NEId, + enmsCcDestPortId PortId, + enmsCcDestTPIdH TPId, + enmsCcDestTPIdL TPId, + enmsCcSrc2NEId NEId, + enmsCcSrc2PortId PortId, + enmsCcSrc2TPIdH TPId, + enmsCcSrc2TPIdL TPId, + enmsCcDest2NEId NEId, + enmsCcDest2PortId PortId, + enmsCcDest2TPIdH TPId, + enmsCcDest2TPIdL TPId, + enmsCcOpState OperationalState, + enmsCcDirection Directionality, + enmsCcProtectionFlag Boolean, + enmsCcProtectionState ProtectionState, + enmsCcNxCount Unsigned32 + } + +enmsCcNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id (table index)." + ::= { enmsCCEntry 1 } + +enmsCcCCId OBJECT-TYPE + SYNTAX CCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "CC identifier within NE (table index)." + ::= { enmsCCEntry 2 } + +enmsCcSrcNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NEId of first A-end TP." + ::= { enmsCCEntry 3 } + +enmsCcSrcPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PortId of first A-end TP." + ::= { enmsCCEntry 4 } + +enmsCcSrcTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TPId of first A-end TP." + ::= { enmsCCEntry 5 } + +enmsCcSrcTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TPId of first A-end TP." + ::= { enmsCCEntry 6 } + +enmsCcDestNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NEId of first Z-end TP." + ::= { enmsCCEntry 7 } + +enmsCcDestPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PortId of first Z-end TP." + ::= { enmsCCEntry 8 } + +enmsCcDestTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TPId of first Z-end TP." + ::= { enmsCCEntry 9 } + +enmsCcDestTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TPId of first Z-end TP." + ::= { enmsCCEntry 10 } + +enmsCcSrc2NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NEId of second A-end TP." + ::= { enmsCCEntry 11 } + +enmsCcSrc2PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PortId of second A-end TP." + ::= { enmsCCEntry 12 } + +enmsCcSrc2TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TPId of second A-end TP." + ::= { enmsCCEntry 13 } + +enmsCcSrc2TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TPId of second A-end TP." + ::= { enmsCCEntry 14 } + +enmsCcDest2NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NEId of second Z-end TP." + ::= { enmsCCEntry 15 } + +enmsCcDest2PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PortId second Z-end TP." + ::= { enmsCCEntry 16 } + +enmsCcDest2TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TPId of second Z-end TP." + ::= { enmsCCEntry 17 } + +enmsCcDest2TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TPId of second Z-end TP." + ::= { enmsCCEntry 18 } + +enmsCcOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational status of the cross connection." + ::= { enmsCCEntry 19 } + +enmsCcDirection OBJECT-TYPE + SYNTAX Directionality + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Directionality of the cross connection." + ::= { enmsCCEntry 20 } + +enmsCcProtectionFlag OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether CC is protected." + ::= { enmsCCEntry 21 } + +enmsCcProtectionState OBJECT-TYPE + SYNTAX ProtectionState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Actual protection state of the cross connection. " +::= { enmsCCEntry 22 } + +enmsCcNxCount OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Used whenever more than a single termination point is connected as a bundle" + ::= { enmsCCEntry 23 } + + +-- -------------------------------------------------------------------------- +-- Subnetwork Connection SNC Table +-- -------------------------------------------------------------------------- + +enmsSNCSNCTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsSNCSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Table of subnetwork connections directly used by subnetwork connections. " + ::= { enmsNetworkSetup 10 } + +enmsSNCSNCEntry OBJECT-TYPE + SYNTAX EnmsSNCSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Entry of the SNCSNCTable. Describes two subnetwork connections which have a client server relation. " + INDEX { enmsSsSNCId, enmsSsServerSNCId } + ::= { enmsSNCSNCTable 1 } + +EnmsSNCSNCEntry ::= SEQUENCE + { + enmsSsSNCId SNCId, + enmsSsServerSNCId SNCId + } + +enmsSsSNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " SNC number used as table index. Mandatory. " + ::= { enmsSNCSNCEntry 1 } + +enmsSsServerSNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Id of a SNC which is used as server for the SNC with the Id enmsSsSNCId. " + ::= { enmsSNCSNCEntry 2 } + + +-- -------------------------------------------------------------------------- +-- Subnetwork Connection CC Table +-- -------------------------------------------------------------------------- + +enmsSNCCCTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsSNCCCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Table of cross connections directly used by subnetwork connections. " + ::= { enmsNetworkSetup 11 } + +enmsSNCCCEntry OBJECT-TYPE + SYNTAX EnmsSNCCCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Entry of the SNCCCTable. Contains the Id of a cross connection which is directly used by a subnetwork connections. " + INDEX { enmsSNCCCSNCId, enmsSNCCCCCId } + ::= { enmsSNCCCTable 1 } + +EnmsSNCCCEntry ::= SEQUENCE + { + enmsSNCCCSNCId SNCId, + enmsSNCCCCCId CCId +} + +enmsSNCCCSNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Id of a SNC . " + ::= { enmsSNCCCEntry 1 } + +enmsSNCCCCCId OBJECT-TYPE + SYNTAX CCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Id of a CC which is directly used by the SNC with the Id enmsScSNCId. " + ::= { enmsSNCCCEntry 2 } + + +-- ------------------------------------------------------------------------------------------------------------------ +-- NE Subnetwork Connection Table (TD1551: Enhance the Performance of the retrival of GFPG paths from TNMS Core) +-- ------------------------------------------------------------------------------------------------------------------ + +enmsNeSNCTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsNeSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " NE Subnetwork connection table. " + ::= { enmsNetworkSetup 12 } + +enmsNeSNCEntry OBJECT-TYPE + SYNTAX EnmsNeSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Entry of the NE subnetwork connection table. " + INDEX { enmsNeScNeId, enmsNeScSNCId } + ::= { enmsNeSNCTable 1 } + +EnmsNeSNCEntry ::= SEQUENCE + { + enmsNeScNeId NEId, + enmsNeScSNCId SNCId, + enmsNeScSrcNEId NEId, + enmsNeScSrcPortId PortId, + enmsNeScSrcTPIdH TPId, + enmsNeScSrcTPIdL TPId, + enmsNeScDestNEId NEId, + enmsNeScDestPortId PortId, + enmsNeScDestTPIdH TPId, + enmsNeScDestTPIdL TPId, + enmsNeScSrc2NEId NEId, + enmsNeScSrc2PortId PortId, + enmsNeScSrc2TPIdH TPId, + enmsNeScSrc2TPIdL TPId, + enmsNeScDest2NEId NEId, + enmsNeScDest2PortId PortId, + enmsNeScDest2TPIdH TPId, + enmsNeScDest2TPIdL TPId, + enmsNeScServiceId ServiceId, + enmsNeScName DisplayString, + enmsNeScOpState OperationalState, + enmsNeScAdminState AdministrativeState, + enmsNeScAlarmSeverity PerceivedSeverity, + enmsNeScBandwidth Bandwidth, + enmsNeScDirection Directionality, + enmsNeScProtectionFlag Boolean, -- obsolete + enmsNeScProtectionInfo SNCProtectionInfo, + enmsNeScNxCount Unsigned32, + enmsNeScSNCOwnerId SNCId, + enmsNeScLayerSet LayerSet, + enmsNeScFragmentLayer LayerSet, + enmsNeScMinBandwidth Bandwidth, + enmsNeScRequiredBandwidth Boolean + } + +enmsNeScNeId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NE number used as table index. Mandatory. " + ::= { enmsNeSNCEntry 1 } + +enmsNeScSNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " SNC number used as table index. Mandatory. " + ::= { enmsNeSNCEntry 2 } + +enmsNeScSrcNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NE number of a A-end TP. Mandatory. " + ::= { enmsNeSNCEntry 3 } + +enmsNeScSrcPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Port number of a A-end TP. Mandatory. " + ::= { enmsNeSNCEntry 4 } + +enmsNeScSrcTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a A-end TP. Mandatory. " + ::= { enmsNeSNCEntry 5 } + +enmsNeScSrcTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a A-end TP. Mandatory. " + ::= { enmsNeSNCEntry 6 } + +enmsNeScDestNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NE number of a Z-end TP. Mandatory. " + ::= { enmsNeSNCEntry 7 } + +enmsNeScDestPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Port number of a Z-end TP. Mandatory. " + ::= { enmsNeSNCEntry 8 } + +enmsNeScDestTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a Z-end TP. Mandatory. " + ::= { enmsNeSNCEntry 9 } + +enmsNeScDestTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a Z-end TP. Mandatory. " + ::= { enmsNeSNCEntry 10 } + +enmsNeScSrc2NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NE number of a second A-end TP. " + ::= { enmsNeSNCEntry 11 } + +enmsNeScSrc2PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Port number of a second A-end TP. " + ::= { enmsNeSNCEntry 12 } + +enmsNeScSrc2TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a second A-end TP. " + ::= { enmsNeSNCEntry 13 } + +enmsNeScSrc2TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a second A-end TP. " + ::= { enmsNeSNCEntry 14 } + +enmsNeScDest2NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NE number of a second Z-end TP. " + ::= { enmsNeSNCEntry 15 } + +enmsNeScDest2PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Port number of a second Z-end TP. " + ::= { enmsNeSNCEntry 16 } + +enmsNeScDest2TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a second Z-end TP. " + ::= { enmsNeSNCEntry 17 } + +enmsNeScDest2TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TP number of a second Z-end TP. " + ::= { enmsNeSNCEntry 18 } + +enmsNeScServiceId OBJECT-TYPE + SYNTAX ServiceId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Service id where this subnetwork connection belongs to. It may be NULL." + ::= { enmsNeSNCEntry 19 } + +enmsNeScName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " SNC name. Mandatory. " + ::= { enmsNeSNCEntry 20 } + +enmsNeScOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Operational status of the subnetwork connection. Mandatory. " + ::= { enmsNeSNCEntry 21 } + +enmsNeScAdminState OBJECT-TYPE + SYNTAX AdministrativeState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Administrativ status of the subnetwork connection. " + ::= { enmsNeSNCEntry 22 } + +enmsNeScAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Alarm status of the subnetwork connection. " + ::= { enmsNeSNCEntry 23 } + +enmsNeScBandwidth OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Bandwidth of the subnetwork connection. " + ::= { enmsNeSNCEntry 24 } + +enmsNeScDirection OBJECT-TYPE + SYNTAX Directionality + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Directionality of the subnetwork connection. " + ::= { enmsNeSNCEntry 25 } + +enmsNeScProtectionFlag OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. if (enmsNeScProtectionInfo==unprotected(1)) then value: false, else value: true. " + ::= { enmsNeSNCEntry 26 } + +enmsNeScProtectionInfo OBJECT-TYPE + SYNTAX SNCProtectionInfo + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " This attribute defines what type of protection has the SNC or + whether there are more than 4 entries in the EnmsSNCTPTable. See SNCProtectionInfo" + ::= { enmsNeSNCEntry 27 } + +enmsNeScNxCount OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Number of channels for concatenated services (n*64k, n*VC4 or n*STMx). " + ::= { enmsNeSNCEntry 28 } + +enmsNeScSNCOwnerId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Global Identifier of the SNC in CDM which uses this SNC in Core. If not existing or for SNC in CDM is null. " + ::= { enmsNeSNCEntry 29 } + +enmsNeScLayerSet OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Layer set of an SNC. " + ::= { enmsNeSNCEntry 30 } + +enmsNeScFragmentLayer OBJECT-TYPE + SYNTAX LayerSet + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " VC4 or VC3 fragment layer in case the SNC represents a virtual + concatenated group SNC, else empty string. " + ::= { enmsNeSNCEntry 31 } + +enmsNeScMinBandwidth OBJECT-TYPE + SYNTAX Bandwidth + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Minimum actual or required bandwidth + of all edges of the SNC connection topology. " + ::= { enmsNeSNCEntry 32 } + +enmsNeScRequiredBandwidth OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Indicates the attribute Bandwidth is required or not. " + ::= { enmsNeSNCEntry 33 } + + + + + + + + + +-- -------------------------------------------------------------------------- +-- Ethernet Path Table +-- -------------------------------------------------------------------------- + +enmsEthernetPathTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsEthernetPathEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all services of the Ethernet Manager." + ::= { enmsNetworkSetup 13 } + +enmsEthernetPathEntry OBJECT-TYPE + SYNTAX EnmsEthernetPathEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the EthernetPath table." + INDEX { enmsEvcEthernetPathId } + ::= { enmsEthernetPathTable 1 } + +EnmsEthernetPathEntry ::= SEQUENCE + { + enmsEvcEthernetPathId EthernetPathId, + enmsEvcName DisplayString, + enmsEvcSVlanId Integer32, + enmsEvcType EthernetPathType, + enmsEvcServiceId ServiceId, + enmsEvcOpState OperationalState, + enmsEvcAdminState AdministrativeState, + enmsEvcAlarmSeverity PerceivedSeverity + } + +enmsEvcEthernetPathId OBJECT-TYPE + SYNTAX EthernetPathId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Ethernet Path Id (table index)." + ::= { enmsEthernetPathEntry 1 } + +enmsEvcName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Name as presented in the TNMS GUI." + ::= { enmsEthernetPathEntry 2 } + +enmsEvcSVlanId OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Internal VLanId." + ::= { enmsEthernetPathEntry 3 } + +enmsEvcType OBJECT-TYPE + SYNTAX EthernetPathType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of Ethernet Path." + ::= { enmsEthernetPathEntry 4 } + +enmsEvcServiceId OBJECT-TYPE + SYNTAX ServiceId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Service where this Ethernet Path belongs to" + ::= { enmsEthernetPathEntry 5 } + +enmsEvcOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state" + ::= { enmsEthernetPathEntry 6 } + +enmsEvcAdminState OBJECT-TYPE + SYNTAX AdministrativeState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Administrative state." + ::= { enmsEthernetPathEntry 7 } + +enmsEvcAlarmSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest severity of all alarms affecting this Ethernet Path." + ::= { enmsEthernetPathEntry 8 } + + + +-- -------------------------------------------------------------------------- +-- +-- TNMS Service Management Layer +-- +-- -------------------------------------------------------------------------- + + +-- -------------------------------------------------------------------------- +-- Subscriber Table +-- -------------------------------------------------------------------------- + +enmsSubscriberTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsSubscriberEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Subscriber table. " + ::= { enmsService 1 } + +enmsSubscriberEntry OBJECT-TYPE + SYNTAX EnmsSubscriberEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Entry of the subscriber table. " + INDEX { enmsSbSubscriberId } + ::= { enmsSubscriberTable 1 } + +EnmsSubscriberEntry ::= SEQUENCE + { + enmsSbSubscriberId SubscriberId, + enmsSbName DisplayString, + enmsSbOrganisation DisplayString, + enmsSbContactPerson DisplayString, + enmsSbAddress DisplayString, + enmsSbPhone DisplayString, + enmsSbFax DisplayString, + enmsSbEMail DisplayString, + enmsSbURL DisplayString, + enmsSbExternalReference DisplayString + } + +enmsSbSubscriberId OBJECT-TYPE + SYNTAX SubscriberId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Global identifier of a subscriber. " + ::= { enmsSubscriberEntry 1 } + +enmsSbName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber name. " + ::= { enmsSubscriberEntry 2 } + +enmsSbOrganisation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber organisation. " + ::= { enmsSubscriberEntry 3 } + +enmsSbContactPerson OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber contact person. " + ::= { enmsSubscriberEntry 4 } + +enmsSbAddress OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber address. " + ::= { enmsSubscriberEntry 5 } + +enmsSbPhone OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber phone. " + ::= { enmsSubscriberEntry 6 } + +enmsSbFax OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber fax. " + ::= { enmsSubscriberEntry 7 } + +enmsSbEMail OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber email. " + ::= { enmsSubscriberEntry 8 } + +enmsSbURL OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber URL. " + ::= { enmsSubscriberEntry 9 } + +enmsSbExternalReference OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Subscriber External Reference. " + ::= { enmsSubscriberEntry 10 } + + +-- -------------------------------------------------------------------------- +-- Service Table +-- -------------------------------------------------------------------------- + +enmsServiceTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsServiceEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Service Table. " + ::= { enmsService 2 } + +enmsServiceEntry OBJECT-TYPE + SYNTAX EnmsServiceEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + " Entry of the service table. " + INDEX { enmsSvServiceId } + ::= { enmsServiceTable 1 } + +EnmsServiceEntry ::= SEQUENCE + { + enmsSvServiceId ServiceId, + enmsSvSubscriberId SubscriberId, + enmsSvLabel DisplayString, + enmsSvOpState OperationalState, + enmsSvAdminState AdministrativeState, + enmsSvDirection Directionality, -- obsolete + enmsSvProtectionFlag Boolean, -- obsolete + enmsSvWriteProtected Boolean, -- obsolete + enmsSvServiceOwnerId ServiceId + } + +enmsSvServiceId OBJECT-TYPE + SYNTAX ServiceId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Global Identifier of a service. " + ::= { enmsServiceEntry 1 } + +enmsSvSubscriberId OBJECT-TYPE + SYNTAX SubscriberId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Identifier of the service possessing subscriber. " + ::= { enmsServiceEntry 2 } + +enmsSvLabel OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Service Label. " + ::= { enmsServiceEntry 3 } + +enmsSvOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Operational state of a service. " + ::= { enmsServiceEntry 4 } + +enmsSvAdminState OBJECT-TYPE + SYNTAX AdministrativeState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Administravice state of a service. " + ::= { enmsServiceEntry 5 } + +enmsSvDirection OBJECT-TYPE + SYNTAX Directionality + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. fix value: unknown(1). " + ::= { enmsServiceEntry 6 } + +enmsSvProtectionFlag OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. fix value: false. " + ::= { enmsServiceEntry 7 } + +enmsSvWriteProtected OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + " obsolete. fix value: false. " + ::= { enmsServiceEntry 8 } + +enmsSvServiceOwnerId OBJECT-TYPE + SYNTAX ServiceId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Global Identifier of the service in CDM which uses this service in Core. If not existing or for services in CDM is null. " + ::= { enmsServiceEntry 9 } + + + +-- -------------------------------------------------------------------------- +-- +-- TNMS Alarm Tables +-- +-- -------------------------------------------------------------------------- + + +-- -------------------------------------------------------------------------- +-- Global Alarm Table +-- -------------------------------------------------------------------------- + +enmsAlarmTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all active alarms in TNMS. Its + single index value (enmsAlAlarmNumber) is not an + identifier of the alarm: it corresponds to the position + of the alarm in the list and therefore may change between + table retrievals. Because of that, this table is not + meant to be accessed randomly, via GET operations. Instead, + it should be retrieved row by row from top to bottom, + using GETNEXT / GETBULK operations. + + The following combination of fields may be used to identify + an alarm and relate it to other tables and traps: + + enmsAlProbableCause + + enmsAlTimeStamp + + enmsAlEntityString + + enmsAlNEId + + enmsAlPortId + + enmsAlTPIdH + + enmsAlTPIdL" + ::= { enmsAlarmTables 1 } + +enmsAlarmEntry OBJECT-TYPE + SYNTAX EnmsAlarmEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarm table." + INDEX { enmsAlAlarmNumber } + ::= { enmsAlarmTable 1 } + +EnmsAlarmEntry ::= +SEQUENCE +{ + enmsAlAlarmNumber Integer32, + enmsAlSeverity PerceivedSeverity, + enmsAlProbableCause ProbableCause, + enmsAlClass AlarmClass, + enmsAlServiceAffect Boolean, + enmsAlState AlarmState, + enmsAlTimeStampFromNE Boolean, + enmsAlTimeStamp EnmsTimeStamp, + enmsAlEntityString DisplayString, + enmsAlEntityType EntityType, + enmsAlNEId NEId, + enmsAlPortId PortId, + enmsAlTPIdH TPId, + enmsAlTPIdL TPId, + enmsAlTPName DisplayString, + enmsAlModuleId ModuleId, + enmsAlProbableCauseString DisplayString, + enmsAlNELocation DisplayString, + enmsAlAffectedLocation DisplayString, + enmsAlTrafficDirection TrafficDirection, + enmsAlAdditionalInformation DisplayString, + enmsAlNeSystemContainer DisplayString +} + +enmsAlAlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Table index. Does not identify the alarm and may change + each time the table is retrieved." + ::= { enmsAlarmEntry 1 } + +enmsAlSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Severity of the alarm." + ::= { enmsAlarmEntry 2 } + +enmsAlProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause of the alarm." + ::= { enmsAlarmEntry 3 } + +enmsAlClass OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Class of the alarm." + ::= { enmsAlarmEntry 4 } + +enmsAlServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm affects a service." + ::= { enmsAlarmEntry 5 } + +enmsAlState OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm has been acknowledged." + ::= { enmsAlarmEntry 6 } + +enmsAlTimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the timestamp has been generated by + the NE or by TNMS." + ::= { enmsAlarmEntry 7 } + +enmsAlTimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Alarm raising timestamp." + ::= { enmsAlarmEntry 8 } + +enmsAlEntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Description of the alarm originating entity." + ::= { enmsAlarmEntry 9 } + +enmsAlEntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of alarm originating entity." + ::= { enmsAlarmEntry 10 } + +enmsAlNEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the originating entity." + ::= { enmsAlarmEntry 11 } + +enmsAlPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the originating entity, if applicable." + ::= { enmsAlarmEntry 12 } + +enmsAlTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of originating entity, if applicable." + ::= { enmsAlarmEntry 13 } + +enmsAlTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of originating entity, if applicable." + ::= { enmsAlarmEntry 14 } + +enmsAlTPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Name of the originating TP, if applicable." + ::= { enmsAlarmEntry 15 } + +enmsAlModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Id of the originating module, if applicable." + ::= { enmsAlarmEntry 16 } + +enmsAlProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause in text form." + ::= { enmsAlarmEntry 17 } + +enmsAlNELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location of originating entity, as reported by the NE itself." + ::= {enmsAlarmEntry 18} + +enmsAlAffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Extended textual description of the alarm originating entity. + Unsupported." + ::= {enmsAlarmEntry 19} + +enmsAlTrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmEntry 20} + +enmsAlAdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmEntry 21} + + +enmsAlNeSystemContainer OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "System name of the originating NE." + ::= {enmsAlarmEntry 22} + +-- -------------------------------------------------------------------------- +-- Alarm Table for NEs: +-- -------------------------------------------------------------------------- + +enmsAlarmsForNETable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForNEEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all alarms originating in an NE or + entities contained in it (modules, ports and TPs)." + ::= { enmsAlarmTables 2 } + +enmsAlarmsForNEEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForNEEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForNE table." + INDEX { enmsA2NEId,enmsA2Severity,enmsA2AlarmNumber } + ::= { enmsAlarmsForNETable 1 } + +EnmsAlarmsForNEEntry ::= +SEQUENCE +{ + enmsA2NEId NEId, + enmsA2Severity PerceivedSeverity, + enmsA2AlarmNumber Integer32, + enmsA2ProbableCause ProbableCause, + enmsA2Class AlarmClass, + enmsA2ServiceAffect Boolean, + enmsA2State AlarmState, + enmsA2TimeStampFromNE Boolean, + enmsA2TimeStamp EnmsTimeStamp, + enmsA2EntityString DisplayString, + enmsA2EntityType EntityType, + enmsA2PortId PortId, + enmsA2TPIdH TPId, + enmsA2TPIdL TPId, + enmsA2TPName DisplayString, + enmsA2ModuleId ModuleId, + enmsA2ProbableCauseString DisplayString, + enmsA2NELocation DisplayString, + enmsA2AffectedLocation DisplayString, + enmsA2TrafficDirection TrafficDirection, + enmsA2AdditionalInformation DisplayString, + enmsA2NeSystemContainer DisplayString +} + +enmsA2NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the originating entity (table index)." + ::= { enmsAlarmsForNEEntry 1 } + +enmsA2Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Severity of the alarm (table index)." + ::= { enmsAlarmsForNEEntry 2 } + +enmsA2AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Additional table index. Does not identify the alarm and + may change each time the table is retrieved." + ::= { enmsAlarmsForNEEntry 3 } + +enmsA2ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause of the alarm." + ::= { enmsAlarmsForNEEntry 4 } + +enmsA2Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Class of the alarm." + ::= { enmsAlarmsForNEEntry 5 } + +enmsA2ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm affects a service." + ::= { enmsAlarmsForNEEntry 6 } + +enmsA2State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm has been acknowledged." + ::= { enmsAlarmsForNEEntry 7 } + +enmsA2TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the timestamp has been generated by the NE or by TNMS." + ::= { enmsAlarmsForNEEntry 8 } + +enmsA2TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Alarm raising timestamp." + ::= { enmsAlarmsForNEEntry 9 } + +enmsA2EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Description of the alarm originating entity." + ::= { enmsAlarmsForNEEntry 10 } + +enmsA2EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of alarm originating entity." + ::= { enmsAlarmsForNEEntry 11 } + +enmsA2PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the originating entity, if applicable." + ::= { enmsAlarmsForNEEntry 12 } + +enmsA2TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of originating entity, if applicable." + ::= { enmsAlarmsForNEEntry 13 } + +enmsA2TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of originating entity, if applicable." + ::= { enmsAlarmsForNEEntry 14 } + +enmsA2TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Name of the originating TP, if applicable." + ::= { enmsAlarmsForNEEntry 15 } + +enmsA2ModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Id of the originating module, if applicable." + ::= { enmsAlarmsForNEEntry 16 } + +enmsA2ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause in text form." + ::= { enmsAlarmsForNEEntry 17 } + +enmsA2NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location of originating entity, as reported by the NE itself." + ::= {enmsAlarmsForNEEntry 18} + +enmsA2AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Extended textual description of the alarm originating entity. Unsupported." + ::= {enmsAlarmsForNEEntry 19} + +enmsA2TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForNEEntry 20} + +enmsA2AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForNEEntry 21} + +enmsA2NeSystemContainer OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "System name of the originating NE." + ::= {enmsAlarmsForNEEntry 22} + +-- -------------------------------------------------------------------------- +-- Alarm table for Port +-- -------------------------------------------------------------------------- + +enmsAlarmsForPortTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForPortEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all alarms originating in a port or a TP contained in it." + ::= { enmsAlarmTables 3 } + +enmsAlarmsForPortEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForPortEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForPort table." + INDEX { enmsA3NEId,enmsA3PortId,enmsA3Severity,enmsA3AlarmNumber } + ::= { enmsAlarmsForPortTable 1 } + +EnmsAlarmsForPortEntry ::= +SEQUENCE +{ + enmsA3NEId NEId, + enmsA3PortId PortId, + enmsA3Severity PerceivedSeverity, + enmsA3AlarmNumber Integer32, + enmsA3ProbableCause ProbableCause, + enmsA3Class AlarmClass, + enmsA3ServiceAffect Boolean, + enmsA3State AlarmState, + enmsA3TimeStampFromNE Boolean, + enmsA3TimeStamp EnmsTimeStamp, + enmsA3EntityString DisplayString, + enmsA3EntityType EntityType, + enmsA3TPIdH TPId, + enmsA3TPIdL TPId, + enmsA3TPName DisplayString, + enmsA3ProbableCauseString DisplayString, + enmsA3NELocation DisplayString, + enmsA3AffectedLocation DisplayString, + enmsA3TrafficDirection TrafficDirection, + enmsA3AdditionalInformation DisplayString, + enmsA3NeSystemContainer DisplayString +} + +enmsA3NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the originating entity (table index). " + ::= { enmsAlarmsForPortEntry 1 } + +enmsA3PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the originating entity (table index)." + ::= { enmsAlarmsForPortEntry 2 } + +enmsA3Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Severity of the alarm (table index)." + ::= { enmsAlarmsForPortEntry 3 } + +enmsA3AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Additional table index. Does not identify the alarm and may change each time the table is retrieved." + ::= { enmsAlarmsForPortEntry 4 } + +enmsA3ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause of the alarm." + ::= { enmsAlarmsForPortEntry 5 } + +enmsA3Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Class of the alarm." + ::= { enmsAlarmsForPortEntry 6 } + +enmsA3ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm affects a service." + ::= { enmsAlarmsForPortEntry 7 } + +enmsA3State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm has been acknowledged." + ::= { enmsAlarmsForPortEntry 8 } + +enmsA3TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the timestamp has been generated by the NE or by TNMS." + ::= { enmsAlarmsForPortEntry 9 } + +enmsA3TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Alarm raising timestamp." + ::= { enmsAlarmsForPortEntry 10 } + +enmsA3EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Description of the alarm originating entity." + ::= { enmsAlarmsForPortEntry 11 } + +enmsA3EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of alarm originating entity." + ::= { enmsAlarmsForPortEntry 12 } + +enmsA3TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of originating entity, if applicable." + ::= { enmsAlarmsForPortEntry 13 } + +enmsA3TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of originating entity, if applicable." + ::= { enmsAlarmsForPortEntry 14 } + +enmsA3TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Name of the originating TP, if applicable." + ::= { enmsAlarmsForPortEntry 15 } + +enmsA3ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause in text form." + ::= { enmsAlarmsForPortEntry 16 } + +enmsA3NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location of originating entity, as reported by the NE itself." + ::= {enmsAlarmsForPortEntry 17} + +enmsA3AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Extended textual description of the alarm originating entity. Unsupported." + ::= {enmsAlarmsForPortEntry 18} + +enmsA3TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForPortEntry 19} + +enmsA3AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForPortEntry 20} + +enmsA3NeSystemContainer OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "System name of the originating NE." + ::= {enmsAlarmsForPortEntry 21} + + +-- -------------------------------------------------------------------------- +-- Alarm Table for TP +-- -------------------------------------------------------------------------- + +enmsAlarmsForTPTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForTPEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all alarms originating in a TP." + ::= { enmsAlarmTables 4 } + +enmsAlarmsForTPEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForTPEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForTP table." + INDEX { enmsA4NEId,enmsA4PortId,enmsA4TPIdH,enmsA4TPIdL,enmsA4Severity,enmsA4AlarmNumber } + ::= { enmsAlarmsForTPTable 1 } + +EnmsAlarmsForTPEntry ::= +SEQUENCE +{ + enmsA4NEId NEId, + enmsA4PortId PortId, + enmsA4TPIdH TPId, + enmsA4TPIdL TPId, + enmsA4Severity PerceivedSeverity, + enmsA4AlarmNumber Integer32, + enmsA4ProbableCause ProbableCause, + enmsA4Class AlarmClass, + enmsA4ServiceAffect Boolean, + enmsA4State AlarmState, + enmsA4TimeStampFromNE Boolean, + enmsA4TimeStamp EnmsTimeStamp, + enmsA4EntityString DisplayString, + enmsA4EntityType EntityType, + enmsA4TPName DisplayString, + enmsA4ProbableCauseString DisplayString, + enmsA4NELocation DisplayString, + enmsA4AffectedLocation DisplayString, + enmsA4TrafficDirection TrafficDirection, + enmsA4AdditionalInformation DisplayString, + enmsA4NeSystemContainer DisplayString +} + +enmsA4NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the originating entity (table index). " + ::= { enmsAlarmsForTPEntry 1 } + +enmsA4PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the originating entity (table index)." + ::= { enmsAlarmsForTPEntry 2 } + +enmsA4TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id of originating entity (table index)." + ::= { enmsAlarmsForTPEntry 3 } + +enmsA4TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id of originating entity (table index)." + ::= { enmsAlarmsForTPEntry 4 } + +enmsA4Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Severity of the alarm (table index)." + ::= { enmsAlarmsForTPEntry 5 } + +enmsA4AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Additional table index. Does not identify the alarm and may change each time the table is retrieved." + ::= { enmsAlarmsForTPEntry 6 } + +enmsA4ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause of the alarm." + ::= { enmsAlarmsForTPEntry 7 } + +enmsA4Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Class of the alarm." + ::= { enmsAlarmsForTPEntry 8 } + +enmsA4ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm affects a service." + ::= { enmsAlarmsForTPEntry 9 } + +enmsA4State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm has been acknowledged." + ::= { enmsAlarmsForTPEntry 10 } + +enmsA4TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the timestamp has been generated by the NE or by TNMS." + ::= { enmsAlarmsForTPEntry 11 } + +enmsA4TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Alarm raising timestamp." + ::= { enmsAlarmsForTPEntry 12 } + +enmsA4EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Description of the alarm originating entity." + ::= { enmsAlarmsForTPEntry 13 } + +enmsA4EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of alarm originating entity." + ::= { enmsAlarmsForTPEntry 14 } + +enmsA4TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Name of the originating TP, if applicable." + ::= { enmsAlarmsForTPEntry 15 } + +enmsA4ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause in text form." + ::= { enmsAlarmsForTPEntry 16 } + +enmsA4NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location of originating entity, as reported by the NE itself." + ::= {enmsAlarmsForTPEntry 17} + +enmsA4AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Extended textual description of the alarm originating entity. Unsupported." + ::= {enmsAlarmsForTPEntry 18} + +enmsA4TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForTPEntry 19} + +enmsA4AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForTPEntry 20} + +enmsA4NeSystemContainer OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "System name of the originating NE." + ::= {enmsAlarmsForTPEntry 21} + +-- -------------------------------------------------------------------------- +-- Alarm Table for Port Connections +-- -------------------------------------------------------------------------- + +enmsAlarmsForPortConnTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForPortConnEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all alarms affecting a port connection, which include all alarms originating in the endpoint ports or in the associated modules. " + ::= { enmsAlarmTables 5 } + +enmsAlarmsForPortConnEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForPortConnEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForPortConn table." + INDEX { enmsA5PortConnId,enmsA5Severity,enmsA5AlarmNumber } + ::= { enmsAlarmsForPortConnTable 1 } + +EnmsAlarmsForPortConnEntry ::= +SEQUENCE +{ + enmsA5PortConnId PortConnId, + enmsA5Severity PerceivedSeverity, + enmsA5AlarmNumber Integer32, + enmsA5ProbableCause ProbableCause, + enmsA5Class AlarmClass, + enmsA5ServiceAffect Boolean, + enmsA5State AlarmState, + enmsA5TimeStampFromNE Boolean, + enmsA5TimeStamp EnmsTimeStamp, + enmsA5EntityString DisplayString, + enmsA5EntityType EntityType, + enmsA5NEId NEId, + enmsA5PortId PortId, + enmsA5TPIdH TPId, -- obsolete + enmsA5TPIdL TPId, -- obsolete + enmsA5TPName DisplayString, -- obsolete + enmsA5ModuleId ModuleId, + enmsA5ProbableCauseString DisplayString, + enmsA5NELocation DisplayString, + enmsA5AffectedLocation DisplayString, + enmsA5TrafficDirection TrafficDirection, + enmsA5AdditionalInformation DisplayString +} + +enmsA5PortConnId OBJECT-TYPE + SYNTAX PortConnId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Id of the Port Connection affected by the alarm (table index)." + ::= { enmsAlarmsForPortConnEntry 1 } + +enmsA5Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Severity of the alarm (table index)." + ::= { enmsAlarmsForPortConnEntry 2 } + +enmsA5AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Additional table index. Does not identify the alarm and may change each time the table is retrieved." + ::= { enmsAlarmsForPortConnEntry 3 } + +enmsA5ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause of the alarm." + ::= { enmsAlarmsForPortConnEntry 4 } + +enmsA5Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Class of the alarm." + ::= { enmsAlarmsForPortConnEntry 5 } + +enmsA5ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm affects a service." + ::= { enmsAlarmsForPortConnEntry 6 } + +enmsA5State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm has been acknowledged." + ::= { enmsAlarmsForPortConnEntry 7 } + +enmsA5TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the timestamp has been generated by the NE or by TNMS." + ::= { enmsAlarmsForPortConnEntry 8 } + +enmsA5TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Alarm raising timestamp." + ::= { enmsAlarmsForPortConnEntry 9 } + +enmsA5EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Description of the alarm originating entity." + ::= { enmsAlarmsForPortConnEntry 10 } + +enmsA5EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of alarm originating entity." + ::= { enmsAlarmsForPortConnEntry 11 } + +enmsA5NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the originating entity." + ::= { enmsAlarmsForPortConnEntry 12 } + +enmsA5PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the originating entity." + ::= { enmsAlarmsForPortConnEntry 13 } + +enmsA5TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Not applicable. Obsolete." + ::= { enmsAlarmsForPortConnEntry 14 } + +enmsA5TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Not applicable. Obsolete." + ::= { enmsAlarmsForPortConnEntry 15 } + +enmsA5TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Not applicable. Obsolete." + ::= { enmsAlarmsForPortConnEntry 16 } + +enmsA5ModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Id of the originating module, if applicable." + ::= { enmsAlarmsForPortConnEntry 17 } + +enmsA5ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause in text form." + ::= { enmsAlarmsForPortConnEntry 18 } + +enmsA5NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location of originating entity, as reported by the NE itself." + ::= {enmsAlarmsForPortConnEntry 19} + +enmsA5AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Extended textual description of the alarm originating entity. Unsupported." + ::= {enmsAlarmsForPortConnEntry 20} + +enmsA5TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForPortConnEntry 21} + +enmsA5AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForPortConnEntry 22} + +-- -------------------------------------------------------------------------- +-- Alarm Table for Subnetwork Connections +-- -------------------------------------------------------------------------- + +enmsAlarmsForSNCTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsAlarmTables 6 } + +enmsAlarmsForSNCEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForSNCEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForSNC table." + INDEX { enmsA6SNCId,enmsA6Severity,enmsA6AlarmNumber } + ::= { enmsAlarmsForSNCTable 1 } + +EnmsAlarmsForSNCEntry ::= +SEQUENCE +{ + enmsA6SNCId SNCId, + enmsA6Severity PerceivedSeverity, + enmsA6AlarmNumber Integer32, + enmsA6ProbableCause ProbableCause, + enmsA6Class AlarmClass, + enmsA6ServiceAffect Boolean, + enmsA6State AlarmState, + enmsA6TimeStampFromNE Boolean, + enmsA6TimeStamp EnmsTimeStamp, + enmsA6EntityString DisplayString, + enmsA6EntityType EntityType, + enmsA6NEId NEId, + enmsA6PortId PortId, + enmsA6TPIdH TPId, + enmsA6TPIdL TPId, + enmsA6TPName DisplayString, + enmsA6ModuleId ModuleId, + enmsA6ProbableCauseString DisplayString, + enmsA6NELocation DisplayString, + enmsA6AffectedLocation DisplayString, + enmsA6TrafficDirection TrafficDirection, + enmsA6AdditionalInformation DisplayString +} + +enmsA6SNCId OBJECT-TYPE + SYNTAX SNCId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " SNCId of a subnetwork connection, where an alarm belongs to. + Intended to use as a query-constraint. " + ::= { enmsAlarmsForSNCEntry 1 } + +enmsA6Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Severity of an alarm. " + ::= { enmsAlarmsForSNCEntry 2 } + +enmsA6AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Table index for the alarm table, but no identifier of an alarm. + The alarmNumber of a particular alarm is subject to change. " + ::= { enmsAlarmsForSNCEntry 3 } + +enmsA6ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ProbableCause of an alarm. " + ::= { enmsAlarmsForSNCEntry 4 } + +enmsA6Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Class of an alarm. " + ::= { enmsAlarmsForSNCEntry 5 } + +enmsA6ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Flag, whether an alarm affects a service or not. " + ::= { enmsAlarmsForSNCEntry 6 } + +enmsA6State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " State, whether an alarm is ackowledged by an administrator. " + ::= { enmsAlarmsForSNCEntry 7 } + +enmsA6TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Flag, whether an alarm timestamp is generated + by NE or by TNMS-Server. " + ::= { enmsAlarmsForSNCEntry 8 } + +enmsA6TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Alarm raising timestamp. " + ::= { enmsAlarmsForSNCEntry 9 } + +enmsA6EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Description of the alarm originating entity (=location). " + ::= { enmsAlarmsForSNCEntry 10 } + +enmsA6EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Type of the alarm originating entity. " + ::= { enmsAlarmsForSNCEntry 11 } + +enmsA6NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NEId of the alarm originating entity (mandatory). " + ::= { enmsAlarmsForSNCEntry 12 } + +enmsA6PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " PortId of the alarm originating entity (optional). " + ::= { enmsAlarmsForSNCEntry 13 } + +enmsA6TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPIdH of the alarm originating entity (optional). " + ::= { enmsAlarmsForSNCEntry 14 } + +enmsA6TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPIdL of the alarm originating entity (optional). " + ::= { enmsAlarmsForSNCEntry 15 } + +enmsA6TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPName of the alarm originating TP (optional). " + ::= { enmsAlarmsForSNCEntry 16 } + +enmsA6ModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ModuleId of the alarm originating entity (optional). " + ::= { enmsAlarmsForSNCEntry 17 } + +enmsA6ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ProbableCause of an alarm in text form. " + ::= { enmsAlarmsForSNCEntry 18 } + +enmsA6NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Location configured by LCT." + ::= {enmsAlarmsForSNCEntry 19} + +enmsA6AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected location. " + ::= {enmsAlarmsForSNCEntry 20} + +enmsA6TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForSNCEntry 21} + +enmsA6AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForSNCEntry 22} + + +-- -------------------------------------------------------------------------- +-- Alarm Table for Services +-- -------------------------------------------------------------------------- + +enmsAlarmsForServiceTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForServiceEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsAlarmTables 7 } + +enmsAlarmsForServiceEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForServiceEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForService table." + INDEX { enmsA7ServiceId,enmsA7Severity,enmsA7AlarmNumber } + ::= { enmsAlarmsForServiceTable 1 } + +EnmsAlarmsForServiceEntry ::= +SEQUENCE +{ + enmsA7ServiceId ServiceId, + enmsA7Severity PerceivedSeverity, + enmsA7AlarmNumber Integer32, + enmsA7ProbableCause ProbableCause, + enmsA7Class AlarmClass, + enmsA7ServiceAffect Boolean, + enmsA7State AlarmState, + enmsA7TimeStampFromNE Boolean, + enmsA7TimeStamp EnmsTimeStamp, + enmsA7EntityString DisplayString, + enmsA7EntityType EntityType, + enmsA7NEId NEId, + enmsA7PortId PortId, + enmsA7TPIdH TPId, + enmsA7TPIdL TPId, + enmsA7TPName DisplayString, + enmsA7ModuleId ModuleId, + enmsA7ProbableCauseString DisplayString, + enmsA7NELocation DisplayString, + enmsA7AffectedLocation DisplayString, + enmsA7TrafficDirection TrafficDirection, + enmsA7AdditionalInformation DisplayString +} + +enmsA7ServiceId OBJECT-TYPE + SYNTAX ServiceId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ServiceId of a service, where an alarm belongs to. + Intended to use as a query-constraint. " + ::= { enmsAlarmsForServiceEntry 1 } + +enmsA7Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Severity of an alarm. " + ::= { enmsAlarmsForServiceEntry 2 } + +enmsA7AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Table index for the alarm table, but no identifier of an alarm. + The alarmNumber of a particular alarm is subject to change. " + ::= { enmsAlarmsForServiceEntry 3 } + +enmsA7ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ProbableCause of an alarm. " + ::= { enmsAlarmsForServiceEntry 4 } + +enmsA7Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Class of an alarm. " + ::= { enmsAlarmsForServiceEntry 5 } + +enmsA7ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Flag, whether an alarm affects a service or not. " + ::= { enmsAlarmsForServiceEntry 6 } + +enmsA7State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " State, whether an alarm is ackowledged by an administrator. " + ::= { enmsAlarmsForServiceEntry 7 } + +enmsA7TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Flag, whether an alarm timestamp is generated + by NE or by TNMS-Server. " + ::= { enmsAlarmsForServiceEntry 8 } + +enmsA7TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Alarm raising timestamp. " + ::= { enmsAlarmsForServiceEntry 9 } + +enmsA7EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Description of the alarm originating entity (=location). " + ::= { enmsAlarmsForServiceEntry 10 } + +enmsA7EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Type of the alarm originating entity. " + ::= { enmsAlarmsForServiceEntry 11 } + +enmsA7NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NEId of the alarm originating entity (mandatory). " + ::= { enmsAlarmsForServiceEntry 12 } + +enmsA7PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " PortId of the alarm originating entity (optional). " + ::= { enmsAlarmsForServiceEntry 13 } + +enmsA7TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPIdH of the alarm originating entity (optional). " + ::= { enmsAlarmsForServiceEntry 14 } + +enmsA7TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPIdL of the alarm originating entity (optional). " + ::= { enmsAlarmsForServiceEntry 15 } + +enmsA7TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPName of the alarm originating TP (optional). " + ::= { enmsAlarmsForServiceEntry 16 } + +enmsA7ModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ModuleId of the alarm originating entity (optional). " + ::= { enmsAlarmsForServiceEntry 17 } + +enmsA7ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ProbableCause of an alarm in text form. " + ::= { enmsAlarmsForServiceEntry 18 } + +enmsA7NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Location configured by LCT." + ::= {enmsAlarmsForServiceEntry 19} + +enmsA7AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected location. " + ::= {enmsAlarmsForServiceEntry 20} + +enmsA7TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForServiceEntry 21} + +enmsA7AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForServiceEntry 22} + + +-- -------------------------------------------------------------------------- +-- Alarm Table for Modules +-- -------------------------------------------------------------------------- + +enmsAlarmsForModuleTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForModuleEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all alarms originating in a module." + ::= { enmsAlarmTables 8 } + +enmsAlarmsForModuleEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForModuleEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForModule table." + INDEX { enmsA8NEId,enmsA8ModuleId,enmsA8Severity,enmsA8AlarmNumber } + ::= { enmsAlarmsForModuleTable 1 } + +EnmsAlarmsForModuleEntry ::= +SEQUENCE +{ + enmsA8NEId NEId, + enmsA8ModuleId ModuleId, + enmsA8Severity PerceivedSeverity, + enmsA8AlarmNumber Integer32, + enmsA8ProbableCause ProbableCause, + enmsA8Class AlarmClass, + enmsA8ServiceAffect Boolean, + enmsA8State AlarmState, + enmsA8TimeStampFromNE Boolean, + enmsA8TimeStamp EnmsTimeStamp, + enmsA8EntityString DisplayString, + enmsA8EntityType EntityType, + enmsA8PortId PortId, -- obsolete + enmsA8TPIdH TPId, -- obsolete + enmsA8TPIdL TPId, -- obsolete + enmsA8TPName DisplayString, -- obsolete + enmsA8ProbableCauseString DisplayString, + enmsA8NELocation DisplayString, + enmsA8AffectedLocation DisplayString, + enmsA8TrafficDirection TrafficDirection, + enmsA8AdditionalInformation DisplayString, + enmsA8NeSystemContainer DisplayString +} + +enmsA8NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NEId of the originating entity (table index). " + ::= { enmsAlarmsForModuleEntry 1 } + +enmsA8ModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "ModuleId of the originating entity (table index)." + ::= { enmsAlarmsForModuleEntry 2 } + +enmsA8Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Severity of the alarm (table index)." + ::= { enmsAlarmsForModuleEntry 3 } + +enmsA8AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Additional table index. Does not identify the alarm and may change each time the table is retrieved." + ::= { enmsAlarmsForModuleEntry 4 } + +enmsA8ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause of the alarm." + ::= { enmsAlarmsForModuleEntry 5 } + +enmsA8Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Class of the alarm." + ::= { enmsAlarmsForModuleEntry 6 } + +enmsA8ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm affects a service." + ::= { enmsAlarmsForModuleEntry 7 } + +enmsA8State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the alarm has been acknowledged." + ::= { enmsAlarmsForModuleEntry 8 } + +enmsA8TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates whether the timestamp has been generated by the NE or by TNMS." + ::= { enmsAlarmsForModuleEntry 9 } + +enmsA8TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Alarm raising timestamp." + ::= { enmsAlarmsForModuleEntry 10 } + +enmsA8EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Description of the alarm originating entity." + ::= { enmsAlarmsForModuleEntry 11 } + +enmsA8EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of alarm originating entity." + ::= { enmsAlarmsForModuleEntry 12 } + +enmsA8PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Not applicable. Obsolete." + ::= { enmsAlarmsForModuleEntry 13 } + +enmsA8TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Not applicable. Obsolete." + ::= { enmsAlarmsForModuleEntry 14 } + +enmsA8TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Not applicable. Obsolete." + ::= { enmsAlarmsForModuleEntry 15 } + +enmsA8TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Not applicable. Obsolete." + ::= { enmsAlarmsForModuleEntry 16 } + +enmsA8ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Probable Cause in text form." + ::= { enmsAlarmsForModuleEntry 17 } + +enmsA8NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location of originating entity, as reported by the NE itself." + ::= {enmsAlarmsForModuleEntry 18} + +enmsA8AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Extended textual description of the alarm originating entity. Unsupported." + ::= {enmsAlarmsForModuleEntry 19} + +enmsA8TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForModuleEntry 20} + +enmsA8AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForModuleEntry 21} + +enmsA8NeSystemContainer OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "System name of the originating NE." + ::= {enmsAlarmsForModuleEntry 22} + +-- -------------------------------------------------------------------------- +-- Alarm Table for Subnetwork Connections +-- -------------------------------------------------------------------------- + +enmsAlarmsForEthernetPathTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsAlarmsForEthernetPathEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Alarms for Ethernet Paths." + ::= { enmsAlarmTables 9 } + +enmsAlarmsForEthernetPathEntry OBJECT-TYPE + SYNTAX EnmsAlarmsForEthernetPathEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the alarmsForEthernetPath table." + INDEX { enmsA9EthernetPathId,enmsA9Severity,enmsA9AlarmNumber } + ::= { enmsAlarmsForEthernetPathTable 1 } + +EnmsAlarmsForEthernetPathEntry ::= +SEQUENCE +{ + enmsA9EthernetPathId EthernetPathId, + enmsA9Severity PerceivedSeverity, + enmsA9AlarmNumber Integer32, + enmsA9ProbableCause ProbableCause, + enmsA9Class AlarmClass, + enmsA9ServiceAffect Boolean, + enmsA9State AlarmState, + enmsA9TimeStampFromNE Boolean, + enmsA9TimeStamp EnmsTimeStamp, + enmsA9EntityString DisplayString, + enmsA9EntityType EntityType, + enmsA9NEId NEId, + enmsA9PortId PortId, + enmsA9TPIdH TPId, + enmsA9TPIdL TPId, + enmsA9TPName DisplayString, + enmsA9ModuleId ModuleId, + enmsA9ProbableCauseString DisplayString, + enmsA9NELocation DisplayString, + enmsA9AffectedLocation DisplayString, + enmsA9TrafficDirection TrafficDirection, + enmsA9AdditionalInformation DisplayString +} + +enmsA9EthernetPathId OBJECT-TYPE + SYNTAX EthernetPathId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " EthernetPathId of a ethernet path, where an alarm belongs to. + Intended to use as a query-constraint. " + ::= { enmsAlarmsForEthernetPathEntry 1 } + +enmsA9Severity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Severity of an alarm. " + ::= { enmsAlarmsForEthernetPathEntry 2 } + +enmsA9AlarmNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Table index for the alarm table, but no identifier of an alarm. + The alarmNumber of a particular alarm is subject to change. " + ::= { enmsAlarmsForEthernetPathEntry 3 } + +enmsA9ProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ProbableCause of an alarm. " + ::= { enmsAlarmsForEthernetPathEntry 4 } + +enmsA9Class OBJECT-TYPE + SYNTAX AlarmClass + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Class of an alarm. " + ::= { enmsAlarmsForEthernetPathEntry 5 } + +enmsA9ServiceAffect OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Flag, whether an alarm affects a service or not. " + ::= { enmsAlarmsForEthernetPathEntry 6 } + +enmsA9State OBJECT-TYPE + SYNTAX AlarmState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " State, whether an alarm is ackowledged by an administrator. " + ::= { enmsAlarmsForEthernetPathEntry 7 } + +enmsA9TimeStampFromNE OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Flag, whether an alarm timestamp is generated + by NE or by TNMS-Server. " + ::= { enmsAlarmsForEthernetPathEntry 8 } + +enmsA9TimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Alarm raising timestamp. " + ::= { enmsAlarmsForEthernetPathEntry 9 } + +enmsA9EntityString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Description of the alarm originating entity (=location). " + ::= { enmsAlarmsForEthernetPathEntry 10 } + +enmsA9EntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Type of the alarm originating entity. " + ::= { enmsAlarmsForEthernetPathEntry 11 } + +enmsA9NEId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " NEId of the alarm originating entity (mandatory). " + ::= { enmsAlarmsForEthernetPathEntry 12 } + +enmsA9PortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " PortId of the alarm originating entity (optional). " + ::= { enmsAlarmsForEthernetPathEntry 13 } + +enmsA9TPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPIdH of the alarm originating entity (optional). " + ::= { enmsAlarmsForEthernetPathEntry 14 } + +enmsA9TPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPIdL of the alarm originating entity (optional). " + ::= { enmsAlarmsForEthernetPathEntry 15 } + +enmsA9TPName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " TPName of the alarm originating TP (optional). " + ::= { enmsAlarmsForEthernetPathEntry 16 } + +enmsA9ModuleId OBJECT-TYPE + SYNTAX ModuleId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ModuleId of the alarm originating entity (optional). " + ::= { enmsAlarmsForEthernetPathEntry 17 } + +enmsA9ProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " ProbableCause of an alarm in text form. " + ::= { enmsAlarmsForEthernetPathEntry 18 } + +enmsA9NELocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Location configured by LCT." + ::= {enmsAlarmsForEthernetPathEntry 19} + +enmsA9AffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected location. " + ::= {enmsAlarmsForEthernetPathEntry 20} + +enmsA9TrafficDirection OBJECT-TYPE + SYNTAX TrafficDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Affected traffic direction. " + ::= {enmsAlarmsForEthernetPathEntry 21} + +enmsA9AdditionalInformation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Optional additional information." + ::= {enmsAlarmsForEthernetPathEntry 22} + +-- -------------------------------------------------------------------------- +-- +-- TNMS Proxy Group +-- +-- -------------------------------------------------------------------------- + + +-- -------------------------------------------------------------------------- +-- Counter +-- -------------------------------------------------------------------------- + +enmsSNMPTrapCnt OBJECT-TYPE + SYNTAX Counter32 + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsCounter 1 } + +enmsSNMPGetCnt OBJECT-TYPE + SYNTAX Counter32 + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsCounter 2 } + +enmsSNMPGetNextCnt OBJECT-TYPE + SYNTAX Counter32 + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsCounter 3 } + +enmsSNMPSetCnt OBJECT-TYPE + SYNTAX Counter32 + MAX-ACCESS read-only + STATUS obsolete + DESCRIPTION + "Obsolete." + ::= { enmsCounter 4 } + + +-- -------------------------------------------------------------------------- +-- Control +-- -------------------------------------------------------------------------- + +enmsProxyName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Proxy name, as defined in the SNMP NBI preferences." + ::= { enmsControl 1 } + +enmsProxyOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Operational state. Always 'enabled', otherwise not possible to retrieve the value." + ::= { enmsControl 2 } + +enmsNetworkName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Network name, as defined in the SNMP NBI preferences." + ::= { enmsControl 3 } + +enmsTrapHistoryTableLength OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Length of the trap history table. This field is writable." + ::= { enmsControl 4 } + +enmsTrapCounter OBJECT-TYPE + SYNTAX Counter32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Trap counter of the last trap sent, or zero if none. The trap counter always resets to zero when TNMS is restarted." + ::= { enmsControl 5 } + +enmsProxyPSTAMP OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Production stamp of the SNMP NBI component." + ::= { enmsControl 6 } + +enmsEnterpriseId OBJECT-TYPE + SYNTAX OBJECT IDENTIFIER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "OID of the enterprise node of the SNMP NBI." + ::= { enmsControl 7 } + +enmsMIBVersion OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Version of the SNMP NBI MIB. Matches the LAST-UPDATE clause in the MIB definition file." + ::= { enmsControl 8 } + +enmsEMSVersion OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " EMS version. " + ::= { enmsControl 9 } + +enmsTimeStampFormat OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + " Format of the timestamp values. " + ::= { enmsControl 10 } + +enmsHeartbeatInterval OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Heartbeat interval in seconds. This field is writable." + ::= { enmsControl 11 } + +enmsHeartbeatOpState OBJECT-TYPE + SYNTAX OperationalState + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Heartbeat operational state. This field is writable." + ::= { enmsControl 12 } + +enmsInformTimeout OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Maximum time the agent waits for a response after sending an Inform. This field is writable." + ::= { enmsControl 13 } + +enmsInformMaxTries OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Maximum number of times an inform is sent. This field is writable." + ::= { enmsControl 14 } + + +-- -------------------------------------------------------------------------- +-- +-- TNMS Proxy Group +-- +-- -------------------------------------------------------------------------- + + +-- -------------------------------------------------------------------------- +-- Trap History Table +-- -------------------------------------------------------------------------- + +enmsTrapHistoryTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsTrapHistoryEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "The notification history table contains information about + the last notifications sent. It is mainly used for data + resynchronization in case of missing notifications because + of network errors." + ::= { enmsTrapHist 1 } + +enmsTrapHistoryEntry OBJECT-TYPE + SYNTAX EnmsTrapHistoryEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the trap history table." + INDEX { enmsHiTrapNumber } + ::= { enmsTrapHistoryTable 1 } + +EnmsTrapHistoryEntry ::= SEQUENCE + { + enmsHiTrapNumber Integer32, + enmsHiTrapEntityType EntityType, + enmsHiTrapFirstId UniqueId, + enmsHiTrapSecondId UniqueId, + enmsHiTrapTPIdH TPId, + enmsHiTrapTPIdL TPId, + enmsHiTrapNfyType NotificationType, + enmsHiTrapCounter Counter32 + } + +enmsHiTrapNumber OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Index for the table. Has no correlation with the trap counter." + ::= { enmsTrapHistoryEntry 1 } + +enmsHiTrapEntityType OBJECT-TYPE + SYNTAX EntityType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of entity associated to the trap." + ::= { enmsTrapHistoryEntry 2 } + +enmsHiTrapFirstId OBJECT-TYPE + SYNTAX UniqueId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "First ID of the entity associated with the trap (NEId / PortConnId / SNCId)." + ::= { enmsTrapHistoryEntry 3 } + +enmsHiTrapSecondId OBJECT-TYPE + SYNTAX UniqueId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Second ID of the entity associated with the trap (ModuleId, PortId). " + ::= { enmsTrapHistoryEntry 4 } + +enmsHiTrapTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Higher 32 bits of TP Id, if applicable." + ::= { enmsTrapHistoryEntry 5 } + +enmsHiTrapTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lower 32 bits of TP Id, if applicable." + ::= { enmsTrapHistoryEntry 6 } + +enmsHiTrapNfyType OBJECT-TYPE + SYNTAX NotificationType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Type of notification (OC, OD, Alarm, etc.)." + ::= { enmsTrapHistoryEntry 7 } + +enmsHiTrapCounter OBJECT-TYPE + SYNTAX Counter32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Trap counter, as has been sent in the trap." + ::= { enmsTrapHistoryEntry 8 } + + +-- -------------------------------------------------------------------------- +-- Trap Variables +-- -------------------------------------------------------------------------- +-- Trap Variables changes from "not-accessible" to "read-only" (hm,1.5.99), +-- access needed for emanate generated trap code. + +enmsTrapTimeStamp OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Timestamp." + ::= { enmsTrapVariable 1 } + +enmsTrapEventSeverity OBJECT-TYPE + SYNTAX PerceivedSeverity + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Severity." + ::= { enmsTrapVariable 2 } + +enmsTrapEventDetails OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Textual description of a event." + ::= { enmsTrapVariable 3 } + +enmsTrapEventProbableCause OBJECT-TYPE + SYNTAX ProbableCause + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "ProbableCause." + ::= { enmsTrapVariable 4 } + +enmsTrapStateName OBJECT-TYPE + SYNTAX INTEGER { + opState(1), + adminState(2), + usageStateTX(3), + usageStateRX(4), + opStateTX(5), + opStateRX(6), + actualCreationState(7), + requiredCreationState(8), + protectionState(9), + communicationState(10) + } + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates which table state field changed." + ::= { enmsTrapVariable 5 } + +enmsTrapStateOldValue OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Old value of the state." + ::= { enmsTrapVariable 6 } + +enmsTrapStateNewValue OBJECT-TYPE + SYNTAX Integer32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "New value of the state." + ::= { enmsTrapVariable 7 } + +enmsTrapAttributeName OBJECT-TYPE + SYNTAX INTEGER { + type(1), + name(2), + location(3), + alarmSeverity(4), + operatingMode(5), + canBroadcast(6), + canPathProtection(7), + neClass(8), + technology(9), + serviceType(10), + interfaceType(11), + bandwidth(12), + direction(13), + tpIndex(14), + nxCount(15), + terminType(16), + moduleId(17), + reliability(18), + label(19), + protectionFlag(20), + writeProtected(21), + organisation(22), + contactPerson(23), + address(24), + phone(25), + fax(26), + email(27), + srcAlarmSeverity(28), + dstAlarmSeverity(29), + provisioningState(30), + alarmState(31), + accessState(32), -- obsolete + emAccessState(33), -- obsolete + neState(34), + subscriberId(35), + usageCountTX(36), + usageCountRX(37), + hasPortconnection(38), + ownerId(39), + neIdName(40), + protectionType(41), + -- (42), (43), (44) currently not used + bandwidthSource(45), + bandwidthSink(46), + bandwidthRequired(47), + objectType(48), + neDCNLocation(49), + systemContainer(50), + vLanId(51), + ethernetPathType(52), + serviceId(53), + enmsNeUserText(54) + } + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Indicates which table non-state field changed." + ::= { enmsTrapVariable 8 } + +enmsTrapAttributeOldValue OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Old value of the attribute." + ::= { enmsTrapVariable 9 } + +enmsTrapAttributeNewValue OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "New value of the attribute." + ::= { enmsTrapVariable 10 } + +enmsTrapEventProbableCauseString OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Textual description of a Probable Cause." + ::= { enmsTrapVariable 11 } + +enmsTrapNeIdName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id name as defined by the operator in TNMS." + ::= { enmsTrapVariable 12 } + +enmsTrapNeLocationLct OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE location as reported by the NE itself." + ::= { enmsTrapVariable 13 } + +enmsTrapAffectedLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Extended textual description of the alarm originating entity. Unsupported." + ::= { enmsTrapVariable 14 } + +enmsTrapEventTrafficDirection OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Traffic direction affected by an alarm." + ::= { enmsTrapVariable 15 } + + +-- -------------------------------------------------------------------------- +-- TNMS Traps +-- -------------------------------------------------------------------------- + +enmsCommonTraps OBJECT IDENTIFIER ::= { enmsTraps 1 } +enmsNETraps OBJECT IDENTIFIER ::= { enmsTraps 2 } +enmsModuleTraps OBJECT IDENTIFIER ::= { enmsTraps 3 } +enmsPortTraps OBJECT IDENTIFIER ::= { enmsTraps 4 } +enmsTPTraps OBJECT IDENTIFIER ::= { enmsTraps 5 } +enmsPortConnTraps OBJECT IDENTIFIER ::= { enmsTraps 6 } +enmsSNCTraps OBJECT IDENTIFIER ::= { enmsTraps 7 } +enmsSubscriberTraps OBJECT IDENTIFIER ::= { enmsTraps 8 } +enmsServiceTraps OBJECT IDENTIFIER ::= { enmsTraps 9 } +enmsEMSTraps OBJECT IDENTIFIER ::= { enmsTraps 10 } +enmsMonitorTraps OBJECT IDENTIFIER ::= { enmsTraps 11 } +enmsEthernetPathTraps OBJECT IDENTIFIER ::= { enmsTraps 12 } +enmsPerfMonTraps OBJECT IDENTIFIER ::= { enmsTraps 13 } +enmsOptPowerMonTraps OBJECT IDENTIFIER ::= { enmsTraps 14 } + +enmsProxyStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsProxyName, + enmsTrapEventDetails, + enmsProxyOpState + } + STATUS current + DESCRIPTION + "Proxy state change trap." + ::= { enmsCommonTraps 1 } + + +enmsNEObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsNeNEId, + enmsNeName, + enmsTrapEventDetails, + enmsTrapNeIdName, + enmsNeSystemContainer, + enmsNeUserText + } + STATUS current + DESCRIPTION + "Notification of an NE object creation." + ::= { enmsNETraps 1 } + +enmsNEObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsNeNEId, + enmsNeName, + enmsTrapEventDetails, + enmsTrapNeIdName, + enmsNeSystemContainer, + enmsNeUserText + } + STATUS current + DESCRIPTION + "Notification of an NE object deletion." + ::= { enmsNETraps 2 } + +enmsNEStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsNeNEId, + enmsNeName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapStateName, + enmsTrapStateOldValue, + enmsTrapStateNewValue, + enmsTrapNeIdName, + enmsNeSystemContainer, + enmsNeUserText + } + STATUS current + DESCRIPTION + "Notification of an NE state change." + ::= { enmsNETraps 3 } + +enmsNEAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsNeNEId, + enmsNeName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue, + enmsTrapNeIdName, + enmsNeSystemContainer, + enmsNeUserText + } + STATUS current + DESCRIPTION + "Notification of an NE non-state attribute value change." + ::= { enmsNETraps 4 } + +enmsNEAlarmTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsNeNEId, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsAlClass, + enmsAlState, + enmsAlTimeStamp, + enmsAlEntityString, + enmsTrapEventProbableCauseString, + enmsNeName, + enmsTrapNeLocationLct, + enmsTrapNeIdName, --add due to TA1350 + enmsTrapAffectedLocation, + enmsTrapEventTrafficDirection, + enmsAlServiceAffect, + enmsAlAdditionalInformation, + enmsAlNeSystemContainer + } + STATUS current + DESCRIPTION + "NE alarm notification." + ::= { enmsNETraps 5 } + + +enmsModuleObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsMoNEId, + enmsMoModuleId, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a module creation." + ::= { enmsModuleTraps 1 } + +enmsModuleObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsMoNEId, + enmsMoModuleId, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a module deletion." + ::= { enmsModuleTraps 2 } + +enmsModuleStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsMoNEId, + enmsMoModuleId, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapStateName, + enmsTrapStateOldValue, + enmsTrapStateNewValue + } + STATUS current + DESCRIPTION + "Notification of a module state change." + ::= { enmsModuleTraps 3 } + +enmsModuleAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsMoNEId, + enmsMoModuleId, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Notification of a module non-state attribute change." + ::= { enmsModuleTraps 4 } + +enmsModuleAlarmTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsMoNEId, + enmsMoModuleId, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsAlClass, + enmsAlState, + enmsAlTimeStamp, + enmsAlEntityString, + enmsTrapEventProbableCauseString, + enmsNeName, + enmsTrapNeLocationLct, + enmsTrapNeIdName, --add due to TA1350 + enmsTrapAffectedLocation, + enmsTrapEventTrafficDirection, + enmsAlServiceAffect, + enmsAlAdditionalInformation, + enmsAlNeSystemContainer + } + STATUS current + DESCRIPTION + "Module alarm notification." + ::= { enmsModuleTraps 5 } + + +enmsPortObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPtNEId, + enmsPtPortId, + enmsPtName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a port creation." + ::= { enmsPortTraps 1 } + +enmsPortObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPtNEId, + enmsPtPortId, + enmsPtName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a port deletion." + ::= { enmsPortTraps 2 } + +enmsPortStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPtNEId, + enmsPtPortId, + enmsPtName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapStateName, + enmsTrapStateOldValue, + enmsTrapStateNewValue + } + STATUS current + DESCRIPTION + "Notification of a port state change." + ::= { enmsPortTraps 3 } + +enmsPortAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPtNEId, + enmsPtPortId, + enmsPtName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Notification of a port non-state attribute value change." + ::= { enmsPortTraps 4 } + +enmsPortAlarmTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPtNEId, + enmsPtPortId, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsAlClass, + enmsAlState, + enmsAlTimeStamp, + enmsAlEntityString, + enmsTrapEventProbableCauseString, + enmsNeName, + enmsTrapNeLocationLct, + enmsTrapNeIdName, --add due to TA1350 + enmsTrapAffectedLocation, + enmsTrapEventTrafficDirection, + enmsAlServiceAffect, + enmsAlAdditionalInformation, + enmsAlNeSystemContainer + } + STATUS current + DESCRIPTION + "Port alarm notification." + ::= { enmsPortTraps 5 } + + +enmsTPObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsTpNEId, + enmsTpPortId, + enmsTpTPIdH, + enmsTpTPIdL, + enmsTpName, + enmsTpTPType, -- obsolete + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a TP creation." + ::= { enmsTPTraps 1 } + +enmsTPObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsTpNEId, + enmsTpPortId, + enmsTpTPIdH, + enmsTpTPIdL, + enmsTpName, + enmsTpTPType, -- obsolete + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a TP deletion." + ::= { enmsTPTraps 2 } + +enmsTPStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsTpNEId, + enmsTpPortId, + enmsTpTPIdH, + enmsTpTPIdL, + enmsTpName, + enmsTpTPType, -- obsolete + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapStateName, + enmsTrapStateOldValue, + enmsTrapStateNewValue + } + STATUS current + DESCRIPTION + "Notification of a TP state change." + ::= { enmsTPTraps 3 } + +enmsTPAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsTpNEId, + enmsTpPortId, + enmsTpTPIdH, + enmsTpTPIdL, + enmsTpName, + enmsTpTPType, -- obsolete + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Notification of a TP non-state attribute value change." + ::= { enmsTPTraps 4 } + +enmsTPAlarmTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsTpNEId, + enmsTpPortId, + enmsTpTPIdH, + enmsTpTPIdL, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsAlClass, + enmsAlState, + enmsAlTimeStamp, + enmsAlEntityString, + enmsTrapEventProbableCauseString, + enmsNeName, + enmsTrapNeLocationLct, + enmsTrapNeIdName, --add due to TA1350 + enmsTrapAffectedLocation, + enmsTrapEventTrafficDirection, + enmsAlServiceAffect, + enmsAlAdditionalInformation, + enmsAlNeSystemContainer + } + STATUS current + DESCRIPTION + "TP alarm notification." + ::= { enmsTPTraps 5 } + + +enmsPortConnObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPcPortConnId, + enmsPcName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a port connection creation." + ::= { enmsPortConnTraps 1 } + +enmsPortConnObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPcPortConnId, + enmsPcName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of a port connection deletion." + ::= { enmsPortConnTraps 2 } + +enmsPortConnAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPcPortConnId, + enmsPcName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Notification of a port connection attribute value change." + ::= { enmsPortConnTraps 3 } + + +enmsSNCObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsScSNCId, + enmsScName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of an SNC creation." + ::= { enmsSNCTraps 1 } + +enmsSNCObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsScSNCId, + enmsScName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of an SNC deletion." + ::= { enmsSNCTraps 2 } + +enmsSNCStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsScSNCId, + enmsScName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapStateName, + enmsTrapStateOldValue, + enmsTrapStateNewValue + } + STATUS current + DESCRIPTION + "Notification of an SNC state change." + ::= { enmsSNCTraps 3 } + +enmsSNCAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsScSNCId, + enmsScName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Notification of an SNC non-state attribute value change." + ::= { enmsSNCTraps 4 } + +enmsSNCTPRelationshipChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsScSNCId, + enmsScName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsSNCTraps 5 } + + +enmsSubscriberObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsSbSubscriberId, + enmsSbName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsSubscriberTraps 1 } + +enmsSubscriberObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsSbSubscriberId, + enmsSbName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsSubscriberTraps 2 } + +enmsSubscriberAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsSbSubscriberId, + enmsSbName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsSubscriberTraps 3 } + + +enmsServiceObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsSvServiceId, + enmsSvLabel, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsServiceTraps 1 } + +enmsServiceObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsSvServiceId, + enmsSvLabel, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsServiceTraps 2 } + +enmsServiceStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsSvServiceId, + enmsSvLabel, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapStateName, + enmsTrapStateOldValue, + enmsTrapStateNewValue + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsServiceTraps 3 } + +enmsServiceAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsSvServiceId, + enmsSvLabel, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsServiceTraps 4 } + + +enmsEMSAlarmTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsAlClass, + enmsAlState, + enmsAlTimeStamp, + enmsAlEntityString, + enmsTrapEventProbableCauseString, + enmsAlAdditionalInformation + } + STATUS current + DESCRIPTION + "Notification of an EMS alarm." + ::= {enmsEMSTraps 1 } + + + +enmsHeartbeatTrap NOTIFICATION-TYPE + OBJECTS + { + enmsProxyName + } + STATUS current + DESCRIPTION + "Agent heartbeat trap." + ::= { enmsMonitorTraps 1 } + +enmsEthernetPathObjectCreationTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsEvcEthernetPathId, + enmsEvcName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of an Ethernet Path creation." + ::= { enmsEthernetPathTraps 1 } + +enmsEthernetPathObjectDeletionTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsEvcEthernetPathId, + enmsEvcName, + enmsTrapEventDetails + } + STATUS current + DESCRIPTION + "Notification of an Ethernet Path deletion." + ::= { enmsEthernetPathTraps 2 } + +enmsEthernetPathStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsEvcEthernetPathId, + enmsEvcName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapStateName, + enmsTrapStateOldValue, + enmsTrapStateNewValue + } + STATUS current + DESCRIPTION + "Notification of an Ethernet Path state change." + ::= { enmsEthernetPathTraps 3 } + +enmsEthernetPathAttributeChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsEvcEthernetPathId, + enmsEvcName, + enmsTrapEventDetails, + enmsTrapEventSeverity, + enmsTrapEventProbableCause, + enmsTrapAttributeName, + enmsTrapAttributeOldValue, + enmsTrapAttributeNewValue + } + STATUS current + DESCRIPTION + "Notification of an Ethernet Path non-state attribute value change." + ::= { enmsEthernetPathTraps 4 } + + + +-- -------------------------------------------------------------------------- +-- Performance Monitoring +-- -------------------------------------------------------------------------- + +enmsPerfMonRequestStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsPmRequestId, + enmsPmRequestName, + enmsPmRequestState, + enmsPmRequestInfo + } + STATUS current + DESCRIPTION + "Notification of a PerfMon request status change." + ::= { enmsPerfMonTraps 1 } + + +-- -------------------------------------------------------------------------- +-- Optical Power Monitoring +-- -------------------------------------------------------------------------- + +enmsOptPowerMonRequestStateChangeTrap NOTIFICATION-TYPE + OBJECTS + { + enmsTrapCounter, + enmsOpmRequestId, + enmsOpmRequestName, + enmsOpmRequestState, + enmsOpmRequestInfo + } + STATUS current + DESCRIPTION + "Notification of a OptPowerMon request status change." + ::= { enmsOptPowerMonTraps 1 } + + + +-- ------------------------------------------------------------------------ +-- Trap Filter (Configuration of traps) +-- ------------------------------------------------------------------------ + +enmsCommonTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether common notifications are enabled." + ::= { enmsTrapFilter 1 } + +enmsNETrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether NE notifications (except alarms) are enabled." + ::= { enmsTrapFilter 2 } + +enmsModuleTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether Module notifications (except alarms) are enabled." + ::= { enmsTrapFilter 3 } + +enmsPortTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether Port notifications (except alarms) are enabled. " + ::= { enmsTrapFilter 4 } + +enmsTPTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether TP notifications (except alarms) are enabled." + ::= { enmsTrapFilter 5 } + +enmsPortConnTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether Port Connection notifications (except alarms) are enabled." + ::= { enmsTrapFilter 6 } + +enmsSNCTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether SNC notifications (except alarms) are enabled." + ::= { enmsTrapFilter 7 } + +enmsSubscriberTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Unsupported." + ::= { enmsTrapFilter 8 } + +enmsServiceTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether Service notifications are enabled." + ::= { enmsTrapFilter 9 } + +enmsNEAlarmTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether NE alarm notifications are enabled." + ::= { enmsTrapFilter 10 } + +enmsModuleAlarmTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether Module alarm notifications are enabled." + ::= { enmsTrapFilter 11 } + +enmsPortAlarmTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether Port alarm notifications are enabled." + ::= { enmsTrapFilter 12 } + +enmsTPAlarmTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether TP alarm notifications are enabled." + ::= { enmsTrapFilter 13 } + +enmsEMSAlarmTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether EMS alarm notifications are enabled." + ::={enmsTrapFilter 14 } + +enmsNeIdNameFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Unsupported." + ::={enmsTrapFilter 15 } + +enmsMonitorTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether monitor notifications are enabled." + ::= { enmsTrapFilter 16 } + +enmsEthernetPathTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether Ethernet Path notifications are enabled." + ::= { enmsTrapFilter 17 } + +enmsPerfMonTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether PerfMon notifications are enabled." + ::= { enmsTrapFilter 18 } + +enmsOptPowerMonTrapFilter OBJECT-TYPE + SYNTAX TrapFilter + MAX-ACCESS read-write + STATUS current + DESCRIPTION + "Indicates whether OptPowerMon notifications are enabled." + ::= { enmsTrapFilter 19 } + + +-- ---------------------------------- +-- PerfMon Request Id generator +-- ---------------------------------- + + +enmsPmRequestNextId OBJECT-TYPE + SYNTAX PerfMonRequestId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Id for the next PerfMon request. Auto-incremented for each GET access." + ::= { enmsPerfMon 1 } + + +-- ---------------------------------- +-- PerfMon Request Table +-- ---------------------------------- + + +enmsPerfMonRequestTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsPerfMonRequestEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all PM data requests." + ::= { enmsPerfMon 2 } + +enmsPerfMonRequestEntry OBJECT-TYPE + SYNTAX EnmsPerfMonRequestEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the PerfMon request table." + INDEX { enmsPmRequestId } + ::= { enmsPerfMonRequestTable 1 } + +EnmsPerfMonRequestEntry ::= SEQUENCE + { + enmsPmRequestId PerfMonRequestId, + enmsPmRequestName DisplayString, + enmsPmRequestRowStatus RowStatus, + enmsPmRequestState PerfMonRequestState, + enmsPmRequestLastUpdate EnmsTimeStamp, + enmsPmRequestInfo DisplayString, + enmsPmRequestType PerfMonType, + enmsPmRequestStartTime EnmsTimeStamp, + enmsPmRequestEndTime EnmsTimeStamp, + enmsPmRequestGranularity PerfMonGranularity, + enmsPmRequestFilterType FilterType, + enmsPmRequestFilterValue DisplayString + } + +enmsPmRequestId OBJECT-TYPE + SYNTAX PerfMonRequestId + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Global PerfMonRequest identifier (table index)." + ::= { enmsPerfMonRequestEntry 1 } + +enmsPmRequestName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Optional request name for manager reference." + ::= { enmsPerfMonRequestEntry 2 } + +enmsPmRequestRowStatus OBJECT-TYPE + SYNTAX RowStatus + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "RowStatus for adding and removing rows." + ::= { enmsPerfMonRequestEntry 3 } + +enmsPmRequestLastUpdate OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Time of the last update of the request." + ::= { enmsPerfMonRequestEntry 4 } + +enmsPmRequestInfo OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Information about request status." + ::= { enmsPerfMonRequestEntry 5 } + +enmsPmRequestState OBJECT-TYPE + SYNTAX PerfMonRequestState + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Request state." + ::= { enmsPerfMonRequestEntry 6 } + +enmsPmRequestType OBJECT-TYPE + SYNTAX PerfMonType + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Type of data to retrieve (history, current or points)." + ::= { enmsPerfMonRequestEntry 7 } + +enmsPmRequestStartTime OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Start time for history PM data." + ::= { enmsPerfMonRequestEntry 8 } + +enmsPmRequestEndTime OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "End time for history PM data" + ::= { enmsPerfMonRequestEntry 9 } + +enmsPmRequestGranularity OBJECT-TYPE + SYNTAX PerfMonGranularity + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Granularity of the data (15m/24h)" + ::= { enmsPerfMonRequestEntry 10 } + +enmsPmRequestFilterType OBJECT-TYPE + SYNTAX FilterType + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Type of object for which to retrieve PM data." + ::= { enmsPerfMonRequestEntry 11 } + +enmsPmRequestFilterValue OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Identifier of the object for which to retrieve PM data." + ::= { enmsPerfMonRequestEntry 12 } + +-- ---------------------------------- +-- PerfMon result PMP table +-- ---------------------------------- + +enmsPerfMonResultPmpTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsPerfMonResultPmpEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains the PMP entries of a PM result set." + ::= { enmsPerfMon 3 } + +enmsPerfMonResultPmpEntry OBJECT-TYPE + SYNTAX EnmsPerfMonResultPmpEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the PerfMon results PMP table." + INDEX { enmsPmResultPmpReqId, enmsPmResultPmpPmpNumber } + ::= { enmsPerfMonResultPmpTable 1 } + +EnmsPerfMonResultPmpEntry ::= SEQUENCE + { + enmsPmResultPmpReqId PerfMonRequestId, + enmsPmResultPmpPmpNumber Unsigned32, + enmsPmResultPmpNeId NEId, + enmsPmResultPmpPortId PortId, + enmsPmResultPmpTPIdH TPId, + enmsPmResultPmpTPIdL TPId, + enmsPmResultPmpNeIdName DisplayString, + enmsPmResultPmpObjLocation DisplayString, + enmsPmResultPmpName DisplayString, + enmsPmResultPmpLocation PerfMonLocation, + enmsPmResultPmpDirection PerfMonDirection, + enmsPmResultPmpRetrievalTime EnmsTimeStamp, + enmsPmResultPmpPeriodEndTime EnmsTimeStamp, + enmsPmResultPmpMonitoredTime Unsigned32, + enmsPmResultPmpNumValues Unsigned32, + enmsPmResultPmpRelatedPaths DisplayString, + enmsPmResultPmpRelatedServices DisplayString, + enmsPmResultPmpRelatedSubscribers DisplayString + } + +enmsPmResultPmpReqId OBJECT-TYPE + SYNTAX PerfMonRequestId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PerfMon request identifier (table index)." + ::= { enmsPerfMonResultPmpEntry 1 } + +enmsPmResultPmpPmpNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of the PMP in the result set. (table index)" + ::= { enmsPerfMonResultPmpEntry 2 } + +enmsPmResultPmpNeId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the PMP." + ::= { enmsPerfMonResultPmpEntry 3 } + +enmsPmResultPmpPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the PMP." + ::= { enmsPerfMonResultPmpEntry 4 } + +enmsPmResultPmpTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest 32-bits of the TP Id of the PMP, if applicable." + ::= { enmsPerfMonResultPmpEntry 5 } + +enmsPmResultPmpTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lowest 32-bits of the TP Id of the PMP, if applicable." + ::= { enmsPerfMonResultPmpEntry 6 } + +enmsPmResultPmpNeIdName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id name of the NE of the PMP." + ::= { enmsPerfMonResultPmpEntry 7 } + +enmsPmResultPmpObjLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Object location of the PMP." + ::= { enmsPerfMonResultPmpEntry 8 } + +enmsPmResultPmpName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PMP name." + ::= { enmsPerfMonResultPmpEntry 9 } + +enmsPmResultPmpLocation OBJECT-TYPE + SYNTAX PerfMonLocation + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PMP location (near end/far end)." + ::= { enmsPerfMonResultPmpEntry 10 } + +enmsPmResultPmpDirection OBJECT-TYPE + SYNTAX PerfMonDirection + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PMP direction." + ::= { enmsPerfMonResultPmpEntry 11 } + +enmsPmResultPmpRetrievalTime OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Retrieval time." + ::= { enmsPerfMonResultPmpEntry 12 } + + +enmsPmResultPmpPeriodEndTime OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "End time of the collection period." + ::= { enmsPerfMonResultPmpEntry 13 } + +enmsPmResultPmpMonitoredTime OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Total monitored time." + ::= { enmsPerfMonResultPmpEntry 14 } + +enmsPmResultPmpNumValues OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of values collected for this PMP." + ::= { enmsPerfMonResultPmpEntry 15 } + +enmsPmResultPmpRelatedPaths OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Names of the paths related to this PMP (comma-separated list, truncated to field size limits). + Only applicable to history data. Only applicable to history data, empty for other types of request. + Requires correlation of PM data to paths to be enabled in the server." + ::= { enmsPerfMonResultPmpEntry 16 } + +enmsPmResultPmpRelatedServices OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Names of the services related to this PMP (comma-separated list, truncated to field size limits). + Only applicable to history data. Only applicable to history data, empty for other types of request. + Requires correlation of PM data to paths to be enabled in the server." + ::= { enmsPerfMonResultPmpEntry 17 } + +enmsPmResultPmpRelatedSubscribers OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Names of the subscribers related to this PMP (comma-separated list, truncated to field size limits). + Only applicable to history data. Only applicable to history data, empty for other types of request. + Requires correlation of PM data to paths to be enabled in the server." + ::= { enmsPerfMonResultPmpEntry 18 } + +-- ---------------------------------- +-- PerfMon result PMP values table +-- ---------------------------------- + +enmsPerfMonResultValueTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsPerfMonResultValueEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains the parameter values for the PMP entries of a PM result set." + ::= { enmsPerfMon 4 } + +enmsPerfMonResultValueEntry OBJECT-TYPE + SYNTAX EnmsPerfMonResultValueEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the PerfMon results PMP table." + INDEX { enmsPmResultValReqId, enmsPmResultValPmpNumber, enmsPmResultValNumber } + ::= { enmsPerfMonResultValueTable 1 } + +EnmsPerfMonResultValueEntry ::= SEQUENCE + { + enmsPmResultValReqId PerfMonRequestId, + enmsPmResultValPmpNumber Unsigned32, + enmsPmResultValNumber Unsigned32, + enmsPmResultValParam DisplayString, + enmsPmResultValValue DisplayString, + enmsPmResultValUnit DisplayString, + enmsPmResultValStatus PerfMonStatus + } + +enmsPmResultValReqId OBJECT-TYPE + SYNTAX PerfMonRequestId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PM request identifier (table index)." + ::= { enmsPerfMonResultValueEntry 1 } + +enmsPmResultValPmpNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of the PMP in the result set. (table index)" + ::= { enmsPerfMonResultValueEntry 2 } + +enmsPmResultValNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of value in the collected values for the PMP. (table index)" + ::= { enmsPerfMonResultValueEntry 3 } + +enmsPmResultValParam OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Parameter name." + ::= { enmsPerfMonResultValueEntry 4 } + +enmsPmResultValValue OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Parameter value." + ::= { enmsPerfMonResultValueEntry 5 } + +enmsPmResultValUnit OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Parameter unit." + ::= { enmsPerfMonResultValueEntry 6 } + +enmsPmResultValStatus OBJECT-TYPE + SYNTAX PerfMonStatus + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Status of the collected value." + ::= { enmsPerfMonResultValueEntry 7 } + + + +-- ---------------------------------- +-- PerfMon result PMP thresholds table +-- ---------------------------------- + +enmsPerfMonResultThresholdTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsPerfMonResultThresholdEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains the parameter thresholds for the PMP entries of a PM result set." + ::= { enmsPerfMon 5 } + +enmsPerfMonResultThresholdEntry OBJECT-TYPE + SYNTAX EnmsPerfMonResultThresholdEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the PerfMon results PMP table." + INDEX { enmsPmResultValReqId, enmsPmResultValPmpNumber, enmsPmResultValNumber } + ::= { enmsPerfMonResultThresholdTable 1 } + +EnmsPerfMonResultThresholdEntry ::= SEQUENCE + { + enmsPmResultThresholdReqId PerfMonRequestId, + enmsPmResultThresholdPmpNumber Unsigned32, + enmsPmResultThresholdNumber Unsigned32, + enmsPmResultThresholdParam DisplayString, + enmsPmResultThresholdType PerfMonThresholdType, + enmsPmResultThresholdTriggerFlag Boolean, + enmsPmResultThresholdValue DisplayString, + enmsPmResultThresholdUnit DisplayString + } + +enmsPmResultThresholdReqId OBJECT-TYPE + SYNTAX PerfMonRequestId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "PM request identifier (table index)." + ::= { enmsPerfMonResultThresholdEntry 1 } + +enmsPmResultThresholdPmpNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of the PMP in the result set. (table index)" + ::= { enmsPerfMonResultThresholdEntry 2 } + +enmsPmResultThresholdNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of threshold in the collected thresholds for the PMP. (table index)" + ::= { enmsPerfMonResultThresholdEntry 3 } + +enmsPmResultThresholdParam OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Parameter name." + ::= { enmsPerfMonResultThresholdEntry 4 } + +enmsPmResultThresholdType OBJECT-TYPE + SYNTAX PerfMonThresholdType + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Parameter threshold type." + ::= { enmsPerfMonResultThresholdEntry 5 } + +enmsPmResultThresholdTriggerFlag OBJECT-TYPE + SYNTAX Boolean + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Trigger flag." + ::= { enmsPerfMonResultThresholdEntry 6 } + +enmsPmResultThresholdValue OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Threshold value." + ::= { enmsPerfMonResultThresholdEntry 7 } + +enmsPmResultThresholdUnit OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Threshold unit." + ::= { enmsPerfMonResultThresholdEntry 8 } + + + +-- -------------------------------------------------------------------------- +-- Optical Power Monitoring +-- -------------------------------------------------------------------------- + +-- ---------------------------------- +-- OptPowerMon Request Id generator +-- ---------------------------------- + + +enmsOpmRequestNextId OBJECT-TYPE + SYNTAX OptPowerMonRequestId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Id for the next OptPowerMon request. Auto-incremented for each GET access." + ::= { enmsOptPowerMon 1 } + + +-- ---------------------------------- +-- OptPowerMon Request Table +-- ---------------------------------- + +enmsOptPowerMonRequestTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsOptPowerMonRequestEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains all PM data requests." + ::= { enmsOptPowerMon 2 } + +enmsOptPowerMonRequestEntry OBJECT-TYPE + SYNTAX EnmsOptPowerMonRequestEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the OptPowerMon request table." + INDEX { enmsOpmRequestId } + ::= { enmsOptPowerMonRequestTable 1 } + +EnmsOptPowerMonRequestEntry ::= SEQUENCE + { + enmsOpmRequestId OptPowerMonRequestId, + enmsOpmRequestName DisplayString, + enmsOpmRequestRowStatus RowStatus, + enmsOpmRequestState OptPowerMonRequestState, + enmsOpmRequestLastUpdate EnmsTimeStamp, + enmsOpmRequestInfo DisplayString, + enmsOpmRequestFilterType FilterType, + enmsOpmRequestFilterValue DisplayString + } + +enmsOpmRequestId OBJECT-TYPE + SYNTAX OptPowerMonRequestId + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Global OptPowerMonRequest identifier (table index)." + ::= { enmsOptPowerMonRequestEntry 1 } + +enmsOpmRequestName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Optional request name for manager reference." + ::= { enmsOptPowerMonRequestEntry 2 } + +enmsOpmRequestRowStatus OBJECT-TYPE + SYNTAX RowStatus + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "RowStatus for adding and removing rows." + ::= { enmsOptPowerMonRequestEntry 3 } + +enmsOpmRequestLastUpdate OBJECT-TYPE + SYNTAX EnmsTimeStamp + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Time of the last update of the request." + ::= { enmsOptPowerMonRequestEntry 4 } + +enmsOpmRequestInfo OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Information about request status." + ::= { enmsOptPowerMonRequestEntry 5 } + +enmsOpmRequestState OBJECT-TYPE + SYNTAX OptPowerMonRequestState + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Request state." + ::= { enmsOptPowerMonRequestEntry 6 } + +enmsOpmRequestFilterType OBJECT-TYPE + SYNTAX FilterType + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Type of object for which to retrieve OPM data." + ::= { enmsOptPowerMonRequestEntry 7 } + +enmsOpmRequestFilterValue OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-create + STATUS current + DESCRIPTION + "Identifier of the object for which to retrieve OPM data." + ::= { enmsOptPowerMonRequestEntry 8 } + + +-- ---------------------------------- +-- OptPowerMon result table +-- ---------------------------------- + +enmsOptPowerMonResultValueTable OBJECT-TYPE + SYNTAX SEQUENCE OF EnmsOptPowerMonResultValueEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "This table contains the OPM values of the OPM request results." + ::= { enmsOptPowerMon 3 } + +enmsOptPowerMonResultValueEntry OBJECT-TYPE + SYNTAX EnmsOptPowerMonResultValueEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "Entry of the OptPowerMon results PMP table." + INDEX { enmsOpmResultValReqId, enmsOpmResultValNumber } + ::= { enmsOptPowerMonResultValueTable 1 } + +EnmsOptPowerMonResultValueEntry ::= SEQUENCE + { + enmsOpmResultValReqId OptPowerMonRequestId, + enmsOpmResultValNumber Unsigned32, + enmsOpmResultValNeId NEId, + enmsOpmResultValPortId PortId, + enmsOpmResultValTPIdH TPId, + enmsOpmResultValTPIdL TPId, + enmsOpmResultValNeIdName DisplayString, + enmsOpmResultValObjLocation DisplayString, + enmsOpmResultValLane Unsigned32, + enmsOpmResultValLayer DisplayString, + enmsOpmResultValParam DisplayString, + enmsOpmResultValValue DisplayString, + enmsOpmResultValUnit DisplayString + } + +enmsOpmResultValReqId OBJECT-TYPE + SYNTAX OptPowerMonRequestId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "OPM request identifier (table index)." + ::= { enmsOptPowerMonResultValueEntry 1 } + +enmsOpmResultValNumber OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Number of value in the result set of the OPM request. (table index)" + ::= { enmsOptPowerMonResultValueEntry 2 } + + +enmsOpmResultValNeId OBJECT-TYPE + SYNTAX NEId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id of the object." + ::= { enmsOptPowerMonResultValueEntry 3 } + +enmsOpmResultValPortId OBJECT-TYPE + SYNTAX PortId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Port Id of the object." + ::= { enmsOptPowerMonResultValueEntry 4 } + +enmsOpmResultValTPIdH OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Highest 32-bits of the TP Id of the object, if applicable." + ::= { enmsOptPowerMonResultValueEntry 5 } + +enmsOpmResultValTPIdL OBJECT-TYPE + SYNTAX TPId + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lowest 32-bits of the TP Id of the object, if applicable." + ::= { enmsOptPowerMonResultValueEntry 6 } + +enmsOpmResultValNeIdName OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "NE Id name of the NE of the PMP." + ::= { enmsOptPowerMonResultValueEntry 7 } + +enmsOpmResultValObjLocation OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Object location of the object." + ::= { enmsOptPowerMonResultValueEntry 8 } + +enmsOpmResultValLane OBJECT-TYPE + SYNTAX Unsigned32 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Lane of the OPM counter." + ::= { enmsOptPowerMonResultValueEntry 9 } + +enmsOpmResultValLayer OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Layer of the OPM counter." + ::= { enmsOptPowerMonResultValueEntry 10 } + +enmsOpmResultValParam OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Counter name." + ::= { enmsOptPowerMonResultValueEntry 11 } + +enmsOpmResultValValue OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Counter value." + ::= { enmsOptPowerMonResultValueEntry 12 } + +enmsOpmResultValUnit OBJECT-TYPE + SYNTAX DisplayString + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Counter unit." + ::= { enmsOptPowerMonResultValueEntry 13 } + + +END |