netconfcentral logo

ietf-alarms@2019-09-11



  module ietf-alarms {

    yang-version 1.1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-alarms";

    prefix al;

    import ietf-yang-types {
      prefix yang;
      reference
        "RFC 6991: Common YANG Data Types.";


    }

    organization "IETF CCAMP Working Group";

    contact
      "WG Web:   <https://trac.ietf.org/trac/ccamp>
WG List:  <mailto:ccamp@ietf.org>

Editor:   Stefan Vallin
	  <mailto:stefan@wallan.se>

Editor:   Martin Bjorklund
	  <mailto:mbj@tail-f.com>";

    description
      "This module defines an interface for managing alarms.  Main
inputs to the module design are the 3GPP Alarm Integration
Reference Point (IRP), ITU-T X.733, and ANSI/ISA-18.2 alarm
standards.
Main features of this module include:

  * Alarm list:
	    A list of all alarms.  Cleared alarms stay in
	    the list until explicitly purged.

  * Operator actions on alarms:
	    Acknowledging and closing alarms.

  * Administrative actions on alarms:
	    Purging alarms from the list according to specific
	    criteria.

  * Alarm inventory:
	    A management application can read all
	    alarm types implemented by the system.

  * Alarm shelving:
	    Shelving (blocking) alarms according
	    to specific criteria.

  * Alarm profiles:
	    A management system can attach further
	    information to alarm types, for example,
	    overriding system-default severity
	    levels.

This module uses a stateful view on alarms.  An alarm is a state
for a specific resource (note that an alarm is not a
notification).  An alarm type is a possible alarm state for a
resource.  For example, the tuple:

  ('link-alarm', 'GigabitEthernet0/25')

is an alarm of type 'link-alarm' on the resource
'GigabitEthernet0/25'.

Alarm types are identified using YANG identities and an optional
string-based qualifier.  The string-based qualifier allows for
dynamic extension of the statically defined alarm types.  Alarm
types identify a possible alarm state and not the individual
notifications.  For example, the traditional 'link-down' and
'link-up' notifications are two notifications referring to the
same alarm type 'link-alarm'.

With this design, there is no ambiguity about how alarm and
alarm clear correlation should be performed; notifications that
report the same resource and alarm type are considered updates
of the same alarm, e.g., clearing an active alarm or changing
the severity of an alarm.  The instrumentation can update the
severity and alarm text on an existing alarm.  The above alarm
example can therefore look like the following:

  (('link-alarm', 'GigabitEthernet0/25'),
   warning,
   'interface down while interface admin state is up')

There is a clear separation between updates on the alarm from
the underlying resource, like clear, and updates from an
operator, like acknowledging or closing an alarm:

  (('link-alarm', 'GigabitEthernet0/25'),
   warning,
   'interface down while interface admin state is up',
   cleared,
   closed)

Administrative actions like removing closed alarms older than a
given time is supported.

This YANG module does not define how the underlying
instrumentation detects and clears the specific alarms.  That
belongs to the Standards Development Organization (SDO) or
enterprise that owns that specific technology.

The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL
NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED',
'MAY', and 'OPTIONAL' in this document are to be interpreted as
described in BCP 14 (RFC 2119) (RFC 8174) when, and only when,
they appear in all capitals, as shown here.

Copyright (c) 2019 IETF Trust and the persons identified as
authors of the code.  All rights reserved.

Redistribution and use in source and binary forms, with or
without modification, is permitted pursuant to, and subject to
the license terms contained in, the Simplified BSD License set
forth in Section 4.c of the IETF Trust's Legal Provisions
Relating to IETF Documents
(https://trustee.ietf.org/license-info).

This version of this YANG module is part of RFC 8632; see
the RFC itself for full legal notices.";

    revision "2019-09-11" {
      description "Initial revision.";
      reference
        "RFC 8632: A YANG Data Model for Alarm Management";

    }


    feature operator-actions {
      description
        "This feature indicates that the system supports operator
states on alarms.";
    }

    feature alarm-shelving {
      description
        "This feature indicates that the system supports shelving
(blocking) alarms.

Alarm shelving may have an impact on server processing
resources in order to match alarms against shelf
criteria.";
    }

    feature alarm-history {
      description
        "This feature indicates that the server maintains a history
of state changes for each alarm.  For example, if an alarm
toggles between cleared and active 10 times, these state
changes are present in a separate list in the alarm.

Keeping the alarm history may have an impact on server
memory resources.";
    }

    feature alarm-summary {
      description
        "This feature indicates that the server summarizes the number
of alarms per severity and operator state.";
    }

    feature alarm-profile {
      description
        "The system enables clients to configure further information
to each alarm type.";
    }

    feature severity-assignment {
      description
        "The system supports configurable alarm severity levels.";
      reference
        "ITU-T Recommendation M.3100:
          Generic network information model
        ITU-T Recommendation M.3160:
          Generic, protocol-neutral management information model";

    }

    feature root-cause-analysis {
      description
        "The system supports identifying candidate root-cause
resources for an alarm, for example, a disk partition
root cause for a logger failure alarm.";
    }

    feature service-impact-analysis {
      description
        "The system supports identifying candidate-impacted
resources for an alarm, for example, an interface state change
resulting in a link alarm, which can refer to a link as being
impacted.";
    }

    feature alarm-correlation {
      description
        "The system supports correlating/grouping alarms
that belong together.";
    }

    identity alarm-type-id {
      base 
      description
        "Base identity for alarm types.  A unique identification of
the alarm, not including the resource.  Different resources
can share alarm types.  If the resource reports the same
alarm type, it is considered to be the same alarm.  The alarm
type is a simplification of the different X.733 and 3GPP Alarm
IRP correlation mechanisms, and it allows for
hierarchical extensions.

A string-based qualifier can be used in addition to the
identity in order to have different alarm types based on
information not known at design time, such as values in
textual SNMP Notification varbinds.

Standards and vendors can define sub-identities to clearly
identify specific alarm types.

This identity is abstract and MUST NOT be used for alarms.";
    }

    typedef resource {
      type union {
        type instance-identifier;
        type yang:object-identifier;
        type string;
        type yang:uuid;
      }
      description
        "This is an identification of the alarming resource, such as an
interface.  It should be as fine-grained as possible to both
guide the operator and guarantee uniqueness of the alarms.

If the alarming resource is modeled in YANG, this type will
be an instance-identifier.

If the resource is an SNMP object, the type will be an
'object-identifier'.

If the resource is anything else, for example, a distinguished
name or a Common Information Model (CIM) path, this type will
be a string.

If the alarming object is identified by a Universally Unique
Identifier (UUID), use the uuid type.  Be cautious when using
this type, since a UUID is hard to use for an operator.

If the server supports several models, the precedence should
be in the order as given in the union definition.";
    }

    typedef resource-match {
      type union {
        type yang:xpath1.0;
        type yang:object-identifier;
        type string;
      }
      description
        "This type is used to match resources of type 'resource'.
Since the type 'resource' is a union of different types, the
'resource-match' type is also a union of corresponding types.

If the type is given as an XPath 1.0 expression, a resource
of type 'instance-identifier' matches if the instance is part
of the node set that is the result of evaluating the XPath 1.0
expression.  For example, the XPath 1.0 expression:

 /ietf-interfaces:interfaces/ietf-interfaces:interface
     [ietf-interfaces:type='ianaift:ethernetCsmacd']

would match the resource instance-identifier:

 /if:interfaces/if:interface[if:name='eth1'],

assuming that the interface 'eth1' is of type
'ianaift:ethernetCsmacd'.

If the type is given as an object identifier, a resource of
type 'object-identifier' matches if the match object
identifier is a prefix of the resource's object identifier.
For example, the value:

 1.3.6.1.2.1.2.2

would match the resource object identifier:

 1.3.6.1.2.1.2.2.1.1.5

If the type is given as an UUID or a string, it is interpreted
as an XML Schema regular expression, which matches a resource
of type 'yang:uuid' or 'string' if the given regular
expression matches the resource string.

If the type is given as an XPath expression, it is evaluated
in the following XPath context:

  o  The set of namespace declarations is the set of prefix
     and namespace pairs for all YANG modules implemented by
     the server, where the prefix is the YANG module name and
     the namespace is as defined by the 'namespace' statement
     in the YANG module.

     If a leaf of this type is encoded in XML, all namespace
     declarations in scope on the leaf element are added to
     the set of namespace declarations.  If a prefix found in
     the XML is already present in the set of namespace
     declarations, the namespace in the XML is used.

  o  The set of variable bindings is empty.

  o  The function library is the core function library, and
     the functions are defined in Section 10 of RFC 7950.

  o  The context node is the root node in the data tree.";
      reference
        "XML Schema Part 2: Datatypes Second Edition,
          World Wide Web Consortium Recommendation
          REC-xmlschema-2-20041028";

    }

    typedef alarm-text {
      type string;
      description
        "The string used to inform operators about the alarm.  This
MUST contain enough information for an operator to be able to
understand the problem and how to resolve it.  If this string
contains structure, this format should be clearly documented
for programs to be able to parse that information.";
    }

    typedef severity {
      type enumeration {
        enum "indeterminate" {
          value 2;
          description
            "Indicates that the severity level could not be
determined.  This level SHOULD be avoided.";
        }
        enum "warning" {
          value 3;
          description
            "The 'warning' severity level indicates the detection of a
potential or impending service-affecting fault, before any
significant effects have been felt.  Action should be
taken to further diagnose (if necessary) and correct the
problem in order to prevent it from becoming a more
serious service-affecting fault.";
        }
        enum "minor" {
          value 4;
          description
            "The 'minor' severity level indicates the existence of a
non-service-affecting fault condition and that corrective
action should be taken in order to prevent a more serious
(for example, service-affecting) fault.  Such a severity
can be reported, for example, when the detected alarm
condition is not currently degrading the capacity of the
resource.";
        }
        enum "major" {
          value 5;
          description
            "The 'major' severity level indicates that a service-
affecting condition has developed and an urgent corrective
action is required.  Such a severity can be reported, for
example, when there is a severe degradation in the
capability of the resource and its full capability must be
restored.";
        }
        enum "critical" {
          value 6;
          description
            "The 'critical' severity level indicates that a service-
affecting condition has occurred and an immediate
corrective action is required.  Such a severity can be
reported, for example, when a resource becomes totally out
of service and its capability must be restored.";
        }
      }
      description
        "The severity level of the alarm.  Note well that the value
'clear' is not included.  Whether or not an alarm is cleared
is a separate boolean flag.";
      reference
        "ITU-T Recommendation X.733: Information Technology
          - Open Systems Interconnection
          - System Management: Alarm Reporting Function";

    }

    typedef severity-with-clear {
      type union {
        type enumeration {
          enum "cleared" {
            value 1;
            description
              "The alarm is cleared by the instrumentation.";
          }
        }
        type severity;
      }
      description
        "The severity level of the alarm including clear.  This is used
only in notifications reporting state changes for an alarm.";
    }

    typedef writable-operator-state {
      type enumeration {
        enum "none" {
          value 1;
          description
            "The alarm is not being taken care of.";
        }
        enum "ack" {
          value 2;
          description
            "The alarm is being taken care of.  Corrective action not
taken yet or has failed";
        }
        enum "closed" {
          value 3;
          description
            "Corrective action taken successfully.";
        }
      }
      description
        "Operator states on an alarm.  The 'closed' state indicates
that an operator considers the alarm being resolved.  This is
separate from the alarm's 'is-cleared' leaf.";
    }

    typedef operator-state {
      type union {
        type writable-operator-state;
        type enumeration {
          enum "shelved" {
            value 4;
            description
              "The alarm is shelved.  Alarms in /alarms/shelved-alarms/
MUST be assigned this operator state by the server as
the last entry in the 'operator-state-change' list.  The
text for that entry SHOULD include the shelf name.";
          }
          enum "un-shelved" {
            value 5;
            description
              "The alarm is moved back to 'alarm-list' from a shelf.
Alarms that are moved from /alarms/shelved-alarms/ to
/alarms/alarm-list MUST be assigned this state by the
server as the last entry in the 'operator-state-change'
list.  The text for that entry SHOULD include the shelf
name.";
          }
        }
      }
      description
        "Operator states on an alarm.  The 'closed' state indicates
that an operator considers the alarm being resolved.  This is
separate from the alarm's 'is-cleared' leaf.";
    }

    typedef alarm-type-id {
      type identityref {
        base alarm-type-id;
      }
      description
        "Identifies an alarm type.  The description of the alarm type
id MUST indicate whether or not the alarm type is abstract.
An abstract alarm type is used as a base for other alarm type
ids and will not be used as a value for an alarm or be present
in the alarm inventory.";
    }

    typedef alarm-type-qualifier {
      type string;
      description
        "If an alarm type cannot be fully specified at design time by
'alarm-type-id', this string qualifier is used in addition to
fully define a unique alarm type.

The definition of alarm qualifiers is considered to be part of
the instrumentation and is out of scope for this module.  An
empty string is used when this is part of a key.";
    }

    container alarms {
      description
        "The top container for this module.";
      container control {
        description
          "Configuration to control the alarm behavior.";
        leaf max-alarm-status-changes {
          type union {
            type uint16;
            type enumeration {
              enum "infinite" {
                value 0;
                description
                  "The status-change entries are accumulated
infinitely.";
              }
            }
          }
          default "32";
          description
            "The 'status-change' entries are kept in a circular list
per alarm.  When this number is exceeded, the oldest
status change entry is automatically removed.  If the
value is 'infinite', the status-change entries are
accumulated infinitely.";
        }

        leaf notify-status-changes {
          type enumeration {
            enum "all-state-changes" {
              value 0;
              description
                "Send notifications for all status changes.";
            }
            enum "raise-and-clear" {
              value 1;
              description
                "Send notifications only for raise, clear, and
re-raise.  Notifications for severity-level changes or
alarm-text changes are not sent.";
            }
            enum "severity-level" {
              value 2;
              description
                "Only send notifications for alarm-state changes
crossing the level specified in
'notify-severity-level'.  Always send clear
notifications.";
            }
          }
          must
            ". != "severity-level" or ../notify-severity-level" {
            description
              "When notify-status-changes is 'severity-level', a value
must be given for 'notify-severity-level'.";
          }
          default "all-state-changes";
          description
            "This leaf controls the notifications sent for alarm status
updates.  There are three options:

1.  Notifications are sent for all updates, severity-level
    changes, and alarm-text changes.

2.  Notifications are only sent for alarm raise and clear.

3.  Notifications are sent for status changes equal to or
    above the specified severity level.  Clear
    notifications shall always be sent.  Notifications
    shall also be sent for state changes that make an
    alarm less severe than the specified level.

For example, in option 3, assume that the severity level
is set to major and that the alarm has the following state
changes:

[(Time, severity, clear)]:
[(T1, major, -), (T2, minor, -), (T3, warning, -),
 (T4, minor, -), (T5, major, -), (T6, critical, -),
 (T7, major.  -), (T8, major, clear)]

In that case, notifications will be sent at times
T1, T2, T5, T6, T7, and T8.";
        }

        leaf notify-severity-level {
          when
            "../notify-status-changes = "severity-level"";
          type severity;
          description
            "Only send notifications for alarm-state changes crossing
the specified level.  Always send clear notifications.";
        }

        container alarm-shelving {
          if-feature alarm-shelving;
          description
            "The 'alarm-shelving/shelf' list is used to shelve
(block/filter) alarms.  The conditions in the shelf
criteria are logically ANDed.  The first matching shelf is
used, and an alarm is shelved only for this first match.
Matching alarms MUST appear in the
/alarms/shelved-alarms/shelved-alarm list, and
non-matching /alarms MUST appear in the
/alarms/alarm-list/alarm list.  The server does not send
any notifications for shelved alarms.

The server MUST maintain states (e.g., severity
changes) for the shelved alarms.

Alarms that match the criteria shall have an
operator state 'shelved'.  When the shelf
configuration removes an alarm from the shelf, the server
shall add the operator state 'un-shelved'.";
          list shelf {
            key "name";
            ordered-by user;
            description
              "Each entry defines the criteria for shelving alarms.
Criteria are ANDed.  If no criteria are specified,
all alarms will be shelved.";
            leaf name {
              type string;
              description
                "An arbitrary name for the alarm shelf.";
            }

            leaf-list resource {
              type resource-match;
              description
                "Shelve alarms for matching resources.";
            }

            list alarm-type {
              key "alarm-type-id alarm-type-qualifier-match";
              description
                "Any alarm matching the combined criteria of
'alarm-type-id' and 'alarm-type-qualifier-match'
MUST be matched.";
              leaf alarm-type-id {
                type alarm-type-id;
                description
                  "Shelve all alarms that have an 'alarm-type-id' that
is equal to or derived from the given
'alarm-type-id'.";
              }

              leaf alarm-type-qualifier-match {
                type string;
                description
                  "An XML Schema regular expression that is used to
match an alarm type qualifier.  Shelve all alarms
that match this regular expression for the alarm
type qualifier.";
                reference
                  "XML Schema Part 2: Datatypes Second Edition,
                    World Wide Web Consortium Recommendation
                    REC-xmlschema-2-20041028";

              }
            }  // list alarm-type

            leaf description {
              type string;
              description
                "An optional textual description of the shelf.  This
description should include the reason for shelving
these alarms.";
            }
          }  // list shelf
        }  // container alarm-shelving

        list x733-mapping {
          if-feature configure-x733-mapping;
          key "alarm-type-id alarm-type-qualifier-match";
          description
            "This list allows a management application to control the
X.733 mapping for all alarm types in the system.  Any entry
in this list will allow the alarm manager to override the
default X.733 mapping in the system, and the final mapping
will be shown in the alarm inventory.";
          leaf alarm-type-id {
            type alarm-type-id;
            description
              "Map the alarm type with this alarm type identifier.";
          }

          leaf alarm-type-qualifier-match {
            type string;
            description
              "A W3C regular expression that is used when mapping an
alarm type and alarm-type-qualifier to X.733 parameters.";
          }

          leaf event-type {
            type event-type;
            description
              "The alarm type has this X.733/X.736 event type.";
          }

          leaf probable-cause {
            type uint32;
            description
              "The alarm type has this X.733 probable cause value.
This module defines probable cause as an integer
and not as an enumeration.  The reason being that the
primary use of probable cause is in the management
application if it is based on the X.733 standard.
However, most management applications have their own
defined enum definitions and merging enums from
different systems might create conflicts.  By using
a configurable uint32, the system can be configured
to match the enum values in the management application.";
          }

          leaf probable-cause-string {
            type string;
            description
              "This string can be used to give a user-friendly string
to the probable cause value.";
          }
        }  // list x733-mapping
      }  // container control

      container alarm-inventory {
        config false;
        description
          "The 'alarm-inventory/alarm-type' list contains all possible
alarm types for the system.

If the system knows for which resources a specific alarm
type can appear, it is also identified in the inventory.
The list also tells if each alarm type has a corresponding
clear state.  The inventory shall only contain concrete
alarm types.

The alarm inventory MUST be updated by the system when new
alarms can appear.  This can be the case when installing new
software modules or inserting new card types.  A
notification 'alarm-inventory-changed' is sent when the
inventory is changed.";
        list alarm-type {
          key "alarm-type-id alarm-type-qualifier";
          description
            "An entry in this list defines a possible alarm.";
          leaf alarm-type-id {
            type alarm-type-id;
            description
              "The statically defined alarm type identifier for this
possible alarm.";
          }

          leaf alarm-type-qualifier {
            type alarm-type-qualifier;
            description
              "The optionally dynamically defined alarm type identifier
for this possible alarm.";
          }

          leaf-list resource {
            type resource-match;
            description
              "Optionally, specifies for which resources the alarm type
is valid.";
          }

          leaf will-clear {
            type boolean;
            mandatory true;
            description
              "This leaf tells the operator if the alarm will be
cleared when the correct corrective action has been
taken.  Implementations SHOULD strive for detecting the
cleared state for all alarm types.

If this leaf is 'true', the operator can monitor the
alarm until it becomes cleared after the corrective
action has been taken.

If this leaf is 'false', the operator needs to validate
that the alarm is no longer active using other
mechanisms.  Alarms can lack a corresponding clear due
to missing instrumentation or no logical
corresponding clear state.";
          }

          leaf-list severity-level {
            type severity;
            description
              "This leaf-list indicates the possible severity levels of
this alarm type.  Note well that 'clear' is not part of
the severity type.  In general, the severity level
should be defined by the instrumentation based on the
dynamic state, rather than being defined statically by
the alarm type, in order to provide a relevant severity
level based on dynamic state and context.  However, most
alarm types have a defined set of possible severity
levels, and this should be provided here.";
          }

          leaf description {
            type string;
            mandatory true;
            description
              "A description of the possible alarm.  It SHOULD include
information on possible underlying root causes and
corrective actions.";
          }

          leaf event-type {
            type event-type;
            description
              "The alarm type has this X.733/X.736 event type.";
          }

          leaf probable-cause {
            type uint32;
            description
              "The alarm type has this X.733 probable cause value.
This module defines probable cause as an integer
and not as an enumeration.  The reason being that the
primary use of probable cause is in the management
application if it is based on the X.733 standard.
However, most management applications have their own
defined enum definitions and merging enums from
different systems might create conflicts.  By using
a configurable uint32, the system can be configured
to match the enum values in the management application.";
          }

          leaf probable-cause-string {
            type string;
            description
              "This string can be used to give a user-friendly string
to the probable cause value.";
          }
        }  // list alarm-type
      }  // container alarm-inventory

      container summary {
        if-feature alarm-summary;
        config false;
        description
          "This container gives a summary of the number of alarms.";
        list alarm-summary {
          key "severity";
          description
            "A global summary of all alarms in the system.  The summary
does not include shelved alarms.";
          leaf severity {
            type severity;
            description
              "Alarm summary for this severity level.";
          }

          leaf total {
            type yang:gauge32;
            description
              "Total number of alarms of this severity level.";
          }

          leaf not-cleared {
            type yang:gauge32;
            description
              "Total number of alarms of this severity level
that are not cleared.";
          }

          leaf cleared {
            type yang:gauge32;
            description
              "For this severity level, the number of alarms that are
cleared.";
          }

          leaf cleared-not-closed {
            if-feature operator-actions;
            type yang:gauge32;
            description
              "For this severity level, the number of alarms that are
cleared but not closed.";
          }

          leaf cleared-closed {
            if-feature operator-actions;
            type yang:gauge32;
            description
              "For this severity level, the number of alarms that are
cleared and closed.";
          }

          leaf not-cleared-closed {
            if-feature operator-actions;
            type yang:gauge32;
            description
              "For this severity level, the number of alarms that are
not cleared but closed.";
          }

          leaf not-cleared-not-closed {
            if-feature operator-actions;
            type yang:gauge32;
            description
              "For this severity level, the number of alarms that are
not cleared and not closed.";
          }
        }  // list alarm-summary

        leaf shelves-active {
          if-feature alarm-shelving;
          type empty;
          description
            "This is a hint to the operator that there are active
alarm shelves.  This leaf MUST exist if the
/alarms/shelved-alarms/number-of-shelved-alarms is > 0.";
        }
      }  // container summary

      container alarm-list {
        config false;
        description
          "The alarms in the system.";
        leaf number-of-alarms {
          type yang:gauge32;
          description
            "This object shows the total number of
alarms in the system, i.e., the total number
of entries in the alarm list.";
        }

        leaf last-changed {
          type yang:date-and-time;
          description
            "A timestamp when the alarm list was last
changed.  The value can be used by a manager to
initiate an alarm resynchronization procedure.";
        }

        list alarm {
          key "resource alarm-type-id alarm-type-qualifier";
          description
            "The list of alarms.  Each entry in the list holds one
alarm for a given alarm type and resource.  An alarm can
be updated from the underlying resource or by the user.
The following leafs are maintained by the resource:
'is-cleared', 'last-change', 'perceived-severity', and
'alarm-text'.  An operator can change 'operator-state' and
'operator-text'.

Entries appear in the alarm list the first time an alarm
becomes active for a given alarm type and resource.
Entries do not get deleted when the alarm is cleared.
Clear status is represented as a boolean flag.

Alarm entries are removed, i.e., purged, from the list by
an explicit purge action.  For example, purge all alarms
that are cleared and in closed operator state that are
older than 24 hours.  Purged alarms are removed from the
alarm list.  If the alarm resource state changes after a
purge, the alarm will reappear in the alarm list.

Systems may also remove alarms based on locally configured
policies; this is out of scope for this module.";
          leaf resource {
            type resource;
            mandatory true;
            description
              "The alarming resource.  See also 'alt-resource'.  This could
be, for example, a reference to the alarming interface";
          }

          leaf alarm-type-id {
            type alarm-type-id;
            mandatory true;
            description
              "This leaf and the leaf 'alarm-type-qualifier' together
provide a unique identification of the alarm type.";
          }

          leaf alarm-type-qualifier {
            type alarm-type-qualifier;
            description
              "This leaf is used when the 'alarm-type-id' leaf cannot
uniquely identify the alarm type.  Normally, this is not the
case, and this leaf is the empty string.";
          }

          leaf-list alt-resource {
            type resource;
            description
              "Used if the alarming resource is available over other
interfaces.  This field can contain SNMP OIDs, CIM paths, or
3GPP distinguished names, for example.";
          }

          list related-alarm {
            if-feature alarm-correlation;
            key "resource alarm-type-id alarm-type-qualifier";
            description
              "References to related alarms.  Note that the related alarm
might have been purged from the alarm list.";
            leaf resource {
              type leafref {
                path "/alarms/alarm-list/alarm/resource";
                require-instance false;
              }
              description
                "The alarming resource for the related alarm.";
            }

            leaf alarm-type-id {
              type leafref {
                path "/alarms/alarm-list/alarm[resource=current()/../resource]/alarm-type-id";
                require-instance false;
              }
              description
                "The alarm type identifier for the related alarm.";
            }

            leaf alarm-type-qualifier {
              type leafref {
                path "/alarms/alarm-list/alarm[resource=current()/../resource][alarm-type-id=current()/../alarm-type-id]/alarm-type-qualifier";
                require-instance false;
              }
              description
                "The alarm qualifier for the related alarm.";
            }
          }  // list related-alarm

          leaf-list impacted-resource {
            if-feature service-impact-analysis;
            type resource;
            description
              "Resources that might be affected by this alarm.  If the
system creates an alarm on a resource and also has a mapping
to other resources that might be impacted, these resources
can be listed in this leaf-list.  In this way, the system
can create one alarm instead of several.  For example, if an
interface has an alarm, the 'impacted-resource' can
reference the aggregated port channels.";
          }

          leaf-list root-cause-resource {
            if-feature root-cause-analysis;
            type resource;
            description
              "Resources that are candidates for causing the alarm.  If the
system has a mechanism to understand the candidate root
causes of an alarm, this leaf-list can be used to list the
root-cause candidate resources.  In this way, the system can
create one alarm instead of several.  An example might be a
logging system (alarm resource) that fails; the alarm can
reference the file system in the 'root-cause-resource'
leaf-list.  Note that the intended use is not to also send
an alarm with the 'root-cause-resource' as an alarming
resource.  The 'root-cause-resource' leaf-list is a hint and
should not also generate an alarm for the same problem.";
          }

          leaf time-created {
            type yang:date-and-time;
            mandatory true;
            description
              "The timestamp when this alarm entry was created.  This
represents the first time the alarm appeared; it can
also represent that the alarm reappeared after a purge.
Further state changes of the same alarm do not change
this leaf; these changes will update the 'last-changed'
leaf.";
          }

          leaf is-cleared {
            type boolean;
            mandatory true;
            description
              "Indicates the current clearance state of the alarm.  An
alarm might toggle from active alarm to cleared alarm and
back to active again.";
          }

          leaf last-raised {
            type yang:date-and-time;
            mandatory true;
            description
              "An alarm may change severity level and toggle between
active and cleared during its lifetime.  This leaf indicates
the last time it was raised ('is-cleared' = 'false').";
          }

          leaf last-changed {
            type yang:date-and-time;
            mandatory true;
            description
              "A timestamp when the 'status-change' or
'operator-state-change' list was last changed.";
          }

          leaf perceived-severity {
            type severity;
            mandatory true;
            description
              "The last severity of the alarm.

If an alarm was raised with severity 'warning' but later
changed to 'major', this leaf will show 'major'.";
          }

          leaf alarm-text {
            type alarm-text;
            mandatory true;
            description
              "The last reported alarm text.  This text should contain
information for an operator to be able to understand the
problem and how to resolve it.";
          }

          list status-change {
            if-feature alarm-history;
            key "time";
            min-elements 1;
            description
              "A list of status-change events for this alarm.

The entry with latest timestamp in this list MUST
correspond to the leafs 'is-cleared', 'perceived-severity',
and 'alarm-text' for the alarm.

This list is ordered according to the timestamps of alarm
state changes.  The first item corresponds to the latest
state change.

The following state changes create an entry in this
list:
- changed severity (warning, minor, major, critical)
- clearance status; this also updates the 'is-cleared'
  leaf
- alarm-text update";
            leaf time {
              type yang:date-and-time;
              mandatory true;
              description
                "The time the status of the alarm changed.  The value
represents the time the real alarm-state change appeared in
the resource and not when it was added to the alarm
list.  The /alarm-list/alarm/last-changed MUST be set to the
same value.";
            }

            leaf perceived-severity {
              type severity-with-clear;
              mandatory true;
              description
                "The severity of the alarm as defined by X.733.  Note that
this may not be the original severity since the alarm may
have changed severity.";
              reference
                "ITU-T Recommendation X.733: Information Technology
                  - Open Systems Interconnection
                  - System Management: Alarm Reporting Function";

            }

            leaf alarm-text {
              type alarm-text;
              mandatory true;
              description
                "A user-friendly text describing the alarm-state change.";
              reference
                "ITU-T Recommendation X.733: Information Technology
                  - Open Systems Interconnection
                  - System Management: Alarm Reporting Function";

            }
          }  // list status-change

          list operator-state-change {
            if-feature operator-actions;
            key "time";
            description
              "This list is used by operators to indicate the state of
human intervention on an alarm.  For example, if an
operator has seen an alarm, the operator can add a new
item to this list indicating that the alarm is
acknowledged.";
            leaf time {
              type yang:date-and-time;
              mandatory true;
              description
                "Timestamp for operator action on the alarm.";
            }

            leaf operator {
              type string;
              mandatory true;
              description
                "The name of the operator that has acted on this alarm.";
            }

            leaf state {
              type operator-state;
              mandatory true;
              description
                "The operator's view of the alarm state.";
            }

            leaf text {
              type string;
              description
                "Additional optional textual information provided by the
operator.";
            }
          }  // list operator-state-change

          action set-operator-state {
            if-feature operator-actions;
            description
              "This is a means for the operator to indicate the level
of human intervention on an alarm.";
            input {
              leaf state {
                type writable-operator-state;
                mandatory true;
                description
                  "Set this operator state.";
              }

              leaf text {
                type string;
                description
                  "Additional optional textual information.";
              }
            }
          }  // rpc set-operator-state

          notification operator-action {
            if-feature operator-actions;
            description
              "This notification is used to report that an operator
acted upon an alarm.";
            leaf time {
              type yang:date-and-time;
              mandatory true;
              description
                "Timestamp for operator action on the alarm.";
            }

            leaf operator {
              type string;
              mandatory true;
              description
                "The name of the operator that has acted on this alarm.";
            }

            leaf state {
              type operator-state;
              mandatory true;
              description
                "The operator's view of the alarm state.";
            }

            leaf text {
              type string;
              description
                "Additional optional textual information provided by the
operator.";
            }
          }  // notification operator-action

          leaf event-type {
            type event-type;
            description
              "The X.733/X.736 event type for this alarm.";
          }

          leaf probable-cause {
            type uint32;
            description
              "The X.733 probable cause for this alarm.";
          }

          leaf probable-cause-string {
            type string;
            description
              "The user-friendly string matching
the probable cause integer value.  The string
SHOULD match the X.733 enumeration.  For example,
value 27 is 'localNodeTransmissionError'.";
          }

          container threshold-information {
            description
              "This parameter shall be present when the alarm
is a result of crossing a threshold. ";
            leaf triggered-threshold {
              type string;
              description
                "The identifier of the threshold attribute that
caused the notification.";
            }

            leaf observed-value {
              type value-type;
              description
                "The value of the gauge or counter that crossed
the threshold.  This may be different from the
threshold value if, for example, the gauge may
only take on discrete values.";
            }

            choice threshold-level {
              description
                "In the case of a gauge, the threshold level specifies
a pair of threshold values: the first is the value
of the crossed threshold, and the second is its
corresponding hysteresis; in the case of a counter,
the threshold level specifies only the threshold
value.";
              case up {
                leaf up-high {
                  type value-type;
                  description
                    "The going-up threshold for raising the alarm.";
                }

                leaf up-low {
                  type value-type;
                  description
                    "The going-down threshold for clearing the alarm.
This is used for hysteresis functions for gauges.";
                }
              }  // case up

              case down {
                leaf down-low {
                  type value-type;
                  description
                    "The going-down threshold for raising the alarm.";
                }

                leaf down-high {
                  type value-type;
                  description
                    "The going-up threshold for clearing the alarm.
This is used for hysteresis functions for gauges.";
                }
              }  // case down
            }  // choice threshold-level

            leaf arm-time {
              type yang:date-and-time;
              description
                "For a gauge threshold, it's the time at which the
threshold was last re-armed; namely, it's the time after
the previous threshold crossing at which the hysteresis
value of the threshold was exceeded, thus again permitting
the generation of notifications when the threshold is
crossed.  For a counter threshold, it's the later of the
time at which the threshold offset was last applied or the
counter was last initialized (for resettable counters).";
            }
          }  // container threshold-information

          list monitored-attributes {
            key "id";
            description
              "The Monitored attributes parameter, when present, defines
one or more attributes of the resource and their
corresponding values at the time of the alarm.";
            leaf id {
              type resource;
              description
                "The resource representing the attribute.";
            }

            leaf value {
              type string;
              description
                "The value represented as a string since it could
be of any type.";
            }
          }  // list monitored-attributes

          leaf-list proposed-repair-actions {
            type string;
            description
              "This parameter, when present, is used if the cause is
known and the system being managed can suggest one or
more solutions (such as switch in standby equipment,
retry, and replace media).";
          }

          leaf trend-indication {
            type trend;
            description
              "This parameter specifies the current severity
trend of the resource.  If present, it indicates
that there are one or more alarms ('outstanding
alarms') that have not been cleared and that
pertain to the same resource as this alarm
('current alarm') does.  The possible values are:

  more-severe: The Perceived severity in the current
    alarm is higher (more severe) than that reported in
    any of the outstanding alarms.

  no-change: The Perceived severity reported in the
    current alarm is the same as the highest (most severe)
    of any of the outstanding alarms.

  less-severe: There is at least one outstanding alarm
    of a severity higher (more severe) than that in the
    current alarm.";
          }

          leaf backedup-status {
            type boolean;
            description
              "This parameter, when present, specifies whether or not the
object emitting the alarm has been backed up; therefore, it
is possible to know whether or not services provided to the
user have been disrupted when this parameter is included.
The use of this field in conjunction with the
'perceived-severity' field provides information in an
independent form to qualify the seriousness of the alarm and
the ability of the system as a whole to continue to provide
services.  If the value of this parameter is true, it
indicates that the object emitting the alarm has been backed
up; if false, the object has not been backed up.";
          }

          leaf backup-object {
            type resource;
            description
              "This parameter SHALL be present when the 'backedup-status'
parameter is present and has the value 'true'.  This
parameter specifies the managed object instance that is
providing back-up services for the managed object to which
the notification pertains.  This parameter is useful, for
example, when the back-up object is from a pool of objects,
any of which may be dynamically allocated to replace a
faulty object.";
          }

          list additional-information {
            key "identifier";
            description
              "This parameter allows the inclusion of an additional
information set in the alarm.  It is a series of data
structures, each of which contains three items of
information: an identifier, a significance indicator,
and the problem information.";
            leaf identifier {
              type string;
              description
                "Identifies the data type of the information parameter.";
            }

            leaf significant {
              type boolean;
              description
                "Set to 'true' if the receiving system must be able to
parse the contents of the information subparameter
for the event report to be fully understood.";
            }

            leaf information {
              type string;
              description
                "Additional information about the alarm.";
            }
          }  // list additional-information

          leaf security-alarm-detector {
            type resource;
            description
              "This parameter identifies the detector of the security
alarm.";
          }

          leaf service-user {
            type resource;
            description
              "This parameter identifies the service-user whose request
for service led to the generation of the security alarm.";
          }

          leaf service-provider {
            type resource;
            description
              "This parameter identifies the intended service-provider
of the service that led to the generation of the security
alarm.";
          }
        }  // list alarm

        action purge-alarms {
          description
            "This operation requests that the server delete entries
from the alarm list according to the supplied criteria.

Typically, this operation is used to delete alarms that
are in closed operator state and older than a specified
time.

The number of purged alarms is returned as an output
parameter.";
          input {
            leaf alarm-clearance-status {
              type enumeration {
                enum "any" {
                  value 0;
                  description
                    "Ignore alarm-clearance status.";
                }
                enum "cleared" {
                  value 1;
                  description
                    "Filter cleared alarms.";
                }
                enum "not-cleared" {
                  value 2;
                  description
                    "Filter not-cleared alarms.";
                }
              }
              mandatory true;
              description
                "The clearance status of the alarm.";
            }

            container older-than {
              presence "Age specification";
              description
                "Matches the 'last-status-change' leaf in the alarm.";
              choice age-spec {
                description
                  "Filter using date and time age.";
                leaf seconds {
                  type uint16;
                  description
                    "Age expressed in seconds.";
                }
                leaf minutes {
                  type uint16;
                  description
                    "Age expressed in minutes.";
                }
                leaf hours {
                  type uint16;
                  description
                    "Age expressed in hours.";
                }
                leaf days {
                  type uint16;
                  description
                    "Age expressed in days.";
                }
                leaf weeks {
                  type uint16;
                  description
                    "Age expressed in weeks.";
                }
              }  // choice age-spec
            }  // container older-than

            container severity {
              presence "Severity filter";
              description
                "Filter based on severity.";
              choice sev-spec {
                description
                  "Filter based on severity level.";
                leaf below {
                  type severity;
                  description
                    "Severity less than this leaf.";
                }
                leaf is {
                  type severity;
                  description
                    "Severity level equal to this leaf.";
                }
                leaf above {
                  type severity;
                  description
                    "Severity level higher than this leaf.";
                }
              }  // choice sev-spec
            }  // container severity

            container operator-state-filter {
              if-feature operator-actions;
              presence
                "Operator state filter";
              description
                "Filter based on operator state.";
              leaf state {
                type operator-state;
                description
                  "Filter on operator state.";
              }

              leaf user {
                type string;
                description
                  "Filter based on which operator.";
              }
            }  // container operator-state-filter
          }

          output {
            leaf purged-alarms {
              type uint32;
              description
                "Number of purged alarms.";
            }
          }
        }  // rpc purge-alarms

        action compress-alarms {
          if-feature alarm-history;
          description
            "This operation requests that the server compress
entries in the alarm list by removing all but the
latest 'status-change' entry for all matching alarms.
Conditions in the input are logically ANDed.  If no
input condition is given, all alarms are compressed.";
          input {
            leaf resource {
              type resource-match;
              description
                "Compress the alarms matching this resource.";
            }

            leaf alarm-type-id {
              type leafref {
                path "/alarms/alarm-list/alarm/alarm-type-id";
                require-instance false;
              }
              description
                "Compress alarms with this 'alarm-type-id'.";
            }

            leaf alarm-type-qualifier {
              type leafref {
                path "/alarms/alarm-list/alarm/alarm-type-qualifier";
                require-instance false;
              }
              description
                "Compress the alarms with this
'alarm-type-qualifier'.";
            }
          }

          output {
            leaf compressed-alarms {
              type uint32;
              description
                "Number of compressed alarm entries.";
            }
          }
        }  // rpc compress-alarms
      }  // container alarm-list

      container shelved-alarms {
        if-feature alarm-shelving;
        config false;
        description
          "The shelved alarms.  Alarms appear here if they match the
criteria in /alarms/control/alarm-shelving.  This list does
not generate any notifications.  The list represents alarms
that are considered not relevant by the operator.  Alarms in
this list have an 'operator-state' of 'shelved'.  This
cannot be changed.";
        leaf number-of-shelved-alarms {
          type yang:gauge32;
          description
            "This object shows the total number of current
alarms, i.e., the total number of entries
in the alarm list.";
        }

        leaf shelved-alarms-last-changed {
          type yang:date-and-time;
          description
            "A timestamp when the shelved-alarm list was last changed.
The value can be used by a manager to initiate an alarm
resynchronization procedure.";
        }

        list shelved-alarm {
          key "resource alarm-type-id alarm-type-qualifier";
          description
            "The list of shelved alarms.  Shelved alarms can only be
updated from the underlying resource; no operator actions
are supported.";
          leaf resource {
            type resource;
            mandatory true;
            description
              "The alarming resource.  See also 'alt-resource'.  This could
be, for example, a reference to the alarming interface";
          }

          leaf alarm-type-id {
            type alarm-type-id;
            mandatory true;
            description
              "This leaf and the leaf 'alarm-type-qualifier' together
provide a unique identification of the alarm type.";
          }

          leaf alarm-type-qualifier {
            type alarm-type-qualifier;
            description
              "This leaf is used when the 'alarm-type-id' leaf cannot
uniquely identify the alarm type.  Normally, this is not the
case, and this leaf is the empty string.";
          }

          leaf-list alt-resource {
            type resource;
            description
              "Used if the alarming resource is available over other
interfaces.  This field can contain SNMP OIDs, CIM paths, or
3GPP distinguished names, for example.";
          }

          list related-alarm {
            if-feature alarm-correlation;
            key "resource alarm-type-id alarm-type-qualifier";
            description
              "References to related alarms.  Note that the related alarm
might have been purged from the alarm list.";
            leaf resource {
              type leafref {
                path "/alarms/alarm-list/alarm/resource";
                require-instance false;
              }
              description
                "The alarming resource for the related alarm.";
            }

            leaf alarm-type-id {
              type leafref {
                path "/alarms/alarm-list/alarm[resource=current()/../resource]/alarm-type-id";
                require-instance false;
              }
              description
                "The alarm type identifier for the related alarm.";
            }

            leaf alarm-type-qualifier {
              type leafref {
                path "/alarms/alarm-list/alarm[resource=current()/../resource][alarm-type-id=current()/../alarm-type-id]/alarm-type-qualifier";
                require-instance false;
              }
              description
                "The alarm qualifier for the related alarm.";
            }
          }  // list related-alarm

          leaf-list impacted-resource {
            if-feature service-impact-analysis;
            type resource;
            description
              "Resources that might be affected by this alarm.  If the
system creates an alarm on a resource and also has a mapping
to other resources that might be impacted, these resources
can be listed in this leaf-list.  In this way, the system
can create one alarm instead of several.  For example, if an
interface has an alarm, the 'impacted-resource' can
reference the aggregated port channels.";
          }

          leaf-list root-cause-resource {
            if-feature root-cause-analysis;
            type resource;
            description
              "Resources that are candidates for causing the alarm.  If the
system has a mechanism to understand the candidate root
causes of an alarm, this leaf-list can be used to list the
root-cause candidate resources.  In this way, the system can
create one alarm instead of several.  An example might be a
logging system (alarm resource) that fails; the alarm can
reference the file system in the 'root-cause-resource'
leaf-list.  Note that the intended use is not to also send
an alarm with the 'root-cause-resource' as an alarming
resource.  The 'root-cause-resource' leaf-list is a hint and
should not also generate an alarm for the same problem.";
          }

          leaf shelf-name {
            type leafref {
              path "/alarms/control/alarm-shelving/shelf/name";
              require-instance false;
            }
            description
              "The name of the shelf.";
          }

          leaf is-cleared {
            type boolean;
            mandatory true;
            description
              "Indicates the current clearance state of the alarm.  An
alarm might toggle from active alarm to cleared alarm and
back to active again.";
          }

          leaf last-raised {
            type yang:date-and-time;
            mandatory true;
            description
              "An alarm may change severity level and toggle between
active and cleared during its lifetime.  This leaf indicates
the last time it was raised ('is-cleared' = 'false').";
          }

          leaf last-changed {
            type yang:date-and-time;
            mandatory true;
            description
              "A timestamp when the 'status-change' or
'operator-state-change' list was last changed.";
          }

          leaf perceived-severity {
            type severity;
            mandatory true;
            description
              "The last severity of the alarm.

If an alarm was raised with severity 'warning' but later
changed to 'major', this leaf will show 'major'.";
          }

          leaf alarm-text {
            type alarm-text;
            mandatory true;
            description
              "The last reported alarm text.  This text should contain
information for an operator to be able to understand the
problem and how to resolve it.";
          }

          list status-change {
            if-feature alarm-history;
            key "time";
            min-elements 1;
            description
              "A list of status-change events for this alarm.

The entry with latest timestamp in this list MUST
correspond to the leafs 'is-cleared', 'perceived-severity',
and 'alarm-text' for the alarm.

This list is ordered according to the timestamps of alarm
state changes.  The first item corresponds to the latest
state change.

The following state changes create an entry in this
list:
- changed severity (warning, minor, major, critical)
- clearance status; this also updates the 'is-cleared'
  leaf
- alarm-text update";
            leaf time {
              type yang:date-and-time;
              mandatory true;
              description
                "The time the status of the alarm changed.  The value
represents the time the real alarm-state change appeared in
the resource and not when it was added to the alarm
list.  The /alarm-list/alarm/last-changed MUST be set to the
same value.";
            }

            leaf perceived-severity {
              type severity-with-clear;
              mandatory true;
              description
                "The severity of the alarm as defined by X.733.  Note that
this may not be the original severity since the alarm may
have changed severity.";
              reference
                "ITU-T Recommendation X.733: Information Technology
                  - Open Systems Interconnection
                  - System Management: Alarm Reporting Function";

            }

            leaf alarm-text {
              type alarm-text;
              mandatory true;
              description
                "A user-friendly text describing the alarm-state change.";
              reference
                "ITU-T Recommendation X.733: Information Technology
                  - Open Systems Interconnection
                  - System Management: Alarm Reporting Function";

            }
          }  // list status-change

          list operator-state-change {
            if-feature operator-actions;
            key "time";
            description
              "This list is used by operators to indicate the state of
human intervention on an alarm.  For shelved alarms, the
system has set the list item in the list to 'shelved'.";
            leaf time {
              type yang:date-and-time;
              mandatory true;
              description
                "Timestamp for operator action on the alarm.";
            }

            leaf operator {
              type string;
              mandatory true;
              description
                "The name of the operator that has acted on this alarm.";
            }

            leaf state {
              type operator-state;
              mandatory true;
              description
                "The operator's view of the alarm state.";
            }

            leaf text {
              type string;
              description
                "Additional optional textual information provided by the
operator.";
            }
          }  // list operator-state-change

          leaf event-type {
            type event-type;
            description
              "The X.733/X.736 event type for this alarm.";
          }

          leaf probable-cause {
            type uint32;
            description
              "The X.733 probable cause for this alarm.";
          }

          leaf probable-cause-string {
            type string;
            description
              "The user-friendly string matching
the probable cause integer value.  The string
SHOULD match the X.733 enumeration.  For example,
value 27 is 'localNodeTransmissionError'.";
          }

          container threshold-information {
            description
              "This parameter shall be present when the alarm
is a result of crossing a threshold. ";
            leaf triggered-threshold {
              type string;
              description
                "The identifier of the threshold attribute that
caused the notification.";
            }

            leaf observed-value {
              type value-type;
              description
                "The value of the gauge or counter that crossed
the threshold.  This may be different from the
threshold value if, for example, the gauge may
only take on discrete values.";
            }

            choice threshold-level {
              description
                "In the case of a gauge, the threshold level specifies
a pair of threshold values: the first is the value
of the crossed threshold, and the second is its
corresponding hysteresis; in the case of a counter,
the threshold level specifies only the threshold
value.";
              case up {
                leaf up-high {
                  type value-type;
                  description
                    "The going-up threshold for raising the alarm.";
                }

                leaf up-low {
                  type value-type;
                  description
                    "The going-down threshold for clearing the alarm.
This is used for hysteresis functions for gauges.";
                }
              }  // case up

              case down {
                leaf down-low {
                  type value-type;
                  description
                    "The going-down threshold for raising the alarm.";
                }

                leaf down-high {
                  type value-type;
                  description
                    "The going-up threshold for clearing the alarm.
This is used for hysteresis functions for gauges.";
                }
              }  // case down
            }  // choice threshold-level

            leaf arm-time {
              type yang:date-and-time;
              description
                "For a gauge threshold, it's the time at which the
threshold was last re-armed; namely, it's the time after
the previous threshold crossing at which the hysteresis
value of the threshold was exceeded, thus again permitting
the generation of notifications when the threshold is
crossed.  For a counter threshold, it's the later of the
time at which the threshold offset was last applied or the
counter was last initialized (for resettable counters).";
            }
          }  // container threshold-information

          list monitored-attributes {
            key "id";
            description
              "The Monitored attributes parameter, when present, defines
one or more attributes of the resource and their
corresponding values at the time of the alarm.";
            leaf id {
              type resource;
              description
                "The resource representing the attribute.";
            }

            leaf value {
              type string;
              description
                "The value represented as a string since it could
be of any type.";
            }
          }  // list monitored-attributes

          leaf-list proposed-repair-actions {
            type string;
            description
              "This parameter, when present, is used if the cause is
known and the system being managed can suggest one or
more solutions (such as switch in standby equipment,
retry, and replace media).";
          }

          leaf trend-indication {
            type trend;
            description
              "This parameter specifies the current severity
trend of the resource.  If present, it indicates
that there are one or more alarms ('outstanding
alarms') that have not been cleared and that
pertain to the same resource as this alarm
('current alarm') does.  The possible values are:

  more-severe: The Perceived severity in the current
    alarm is higher (more severe) than that reported in
    any of the outstanding alarms.

  no-change: The Perceived severity reported in the
    current alarm is the same as the highest (most severe)
    of any of the outstanding alarms.

  less-severe: There is at least one outstanding alarm
    of a severity higher (more severe) than that in the
    current alarm.";
          }

          leaf backedup-status {
            type boolean;
            description
              "This parameter, when present, specifies whether or not the
object emitting the alarm has been backed up; therefore, it
is possible to know whether or not services provided to the
user have been disrupted when this parameter is included.
The use of this field in conjunction with the
'perceived-severity' field provides information in an
independent form to qualify the seriousness of the alarm and
the ability of the system as a whole to continue to provide
services.  If the value of this parameter is true, it
indicates that the object emitting the alarm has been backed
up; if false, the object has not been backed up.";
          }

          leaf backup-object {
            type resource;
            description
              "This parameter SHALL be present when the 'backedup-status'
parameter is present and has the value 'true'.  This
parameter specifies the managed object instance that is
providing back-up services for the managed object to which
the notification pertains.  This parameter is useful, for
example, when the back-up object is from a pool of objects,
any of which may be dynamically allocated to replace a
faulty object.";
          }

          list additional-information {
            key "identifier";
            description
              "This parameter allows the inclusion of an additional
information set in the alarm.  It is a series of data
structures, each of which contains three items of
information: an identifier, a significance indicator,
and the problem information.";
            leaf identifier {
              type string;
              description
                "Identifies the data type of the information parameter.";
            }

            leaf significant {
              type boolean;
              description
                "Set to 'true' if the receiving system must be able to
parse the contents of the information subparameter
for the event report to be fully understood.";
            }

            leaf information {
              type string;
              description
                "Additional information about the alarm.";
            }
          }  // list additional-information

          leaf security-alarm-detector {
            type resource;
            description
              "This parameter identifies the detector of the security
alarm.";
          }

          leaf service-user {
            type resource;
            description
              "This parameter identifies the service-user whose request
for service led to the generation of the security alarm.";
          }

          leaf service-provider {
            type resource;
            description
              "This parameter identifies the intended service-provider
of the service that led to the generation of the security
alarm.";
          }
        }  // list shelved-alarm

        action purge-shelved-alarms {
          description
            "This operation requests that the server delete entries from
the shelved-alarm list according to the supplied criteria.
In the shelved-alarm list, it makes sense to delete alarms
that are not relevant anymore.

The number of purged alarms is returned as an output
parameter.";
          input {
            leaf alarm-clearance-status {
              type enumeration {
                enum "any" {
                  value 0;
                  description
                    "Ignore alarm-clearance status.";
                }
                enum "cleared" {
                  value 1;
                  description
                    "Filter cleared alarms.";
                }
                enum "not-cleared" {
                  value 2;
                  description
                    "Filter not-cleared alarms.";
                }
              }
              mandatory true;
              description
                "The clearance status of the alarm.";
            }

            container older-than {
              presence "Age specification";
              description
                "Matches the 'last-status-change' leaf in the alarm.";
              choice age-spec {
                description
                  "Filter using date and time age.";
                leaf seconds {
                  type uint16;
                  description
                    "Age expressed in seconds.";
                }
                leaf minutes {
                  type uint16;
                  description
                    "Age expressed in minutes.";
                }
                leaf hours {
                  type uint16;
                  description
                    "Age expressed in hours.";
                }
                leaf days {
                  type uint16;
                  description
                    "Age expressed in days.";
                }
                leaf weeks {
                  type uint16;
                  description
                    "Age expressed in weeks.";
                }
              }  // choice age-spec
            }  // container older-than

            container severity {
              presence "Severity filter";
              description
                "Filter based on severity.";
              choice sev-spec {
                description
                  "Filter based on severity level.";
                leaf below {
                  type severity;
                  description
                    "Severity less than this leaf.";
                }
                leaf is {
                  type severity;
                  description
                    "Severity level equal to this leaf.";
                }
                leaf above {
                  type severity;
                  description
                    "Severity level higher than this leaf.";
                }
              }  // choice sev-spec
            }  // container severity

            container operator-state-filter {
              if-feature operator-actions;
              presence
                "Operator state filter";
              description
                "Filter based on operator state.";
              leaf state {
                type operator-state;
                description
                  "Filter on operator state.";
              }

              leaf user {
                type string;
                description
                  "Filter based on which operator.";
              }
            }  // container operator-state-filter
          }

          output {
            leaf purged-alarms {
              type uint32;
              description
                "Number of purged alarms.";
            }
          }
        }  // rpc purge-shelved-alarms

        action compress-shelved-alarms {
          if-feature alarm-history;
          description
            "This operation requests that the server compress entries
in the shelved-alarm list by removing all but the latest
'status-change' entry for all matching shelved alarms.
Conditions in the input are logically ANDed.  If no input
condition is given, all alarms are compressed.";
          input {
            leaf resource {
              type leafref {
                path "/alarms/shelved-alarms/shelved-alarm/resource";
                require-instance false;
              }
              description
                "Compress the alarms with this resource.";
            }

            leaf alarm-type-id {
              type leafref {
                path "/alarms/shelved-alarms/shelved-alarm/alarm-type-id";
                require-instance false;
              }
              description
                "Compress alarms with this 'alarm-type-id'.";
            }

            leaf alarm-type-qualifier {
              type leafref {
                path "/alarms/shelved-alarms/shelved-alarm/alarm-type-qualifier";
                require-instance false;
              }
              description
                "Compress the alarms with this
'alarm-type-qualifier'.";
            }
          }

          output {
            leaf compressed-alarms {
              type uint32;
              description
                "Number of compressed alarm entries.";
            }
          }
        }  // rpc compress-shelved-alarms
      }  // container shelved-alarms

      list alarm-profile {
        if-feature alarm-profile;
        key "alarm-type-id alarm-type-qualifier-match resource";
        ordered-by user;
        description
          "This list is used to assign further information or
configuration for each alarm type.  This module supports a
mechanism where the client can override the system-default
alarm severity levels.  The 'alarm-profile' is also a useful
augmentation point for specific additions to alarm types.";
        leaf alarm-type-id {
          type alarm-type-id;
          description
            "The alarm type identifier to match.";
        }

        leaf alarm-type-qualifier-match {
          type string;
          description
            "An XML Schema regular expression that is used to match the
alarm type qualifier.";
          reference
            "XML Schema Part 2: Datatypes Second Edition,
              World Wide Web Consortium Recommendation
              REC-xmlschema-2-20041028";

        }

        leaf resource {
          type resource-match;
          description
            "Specifies which resources to match.";
        }

        leaf description {
          type string;
          mandatory true;
          description
            "A description of the alarm profile.";
        }

        container alarm-severity-assignment-profile {
          if-feature severity-assignment;
          description
            "The client can override the system-default severity
level.";
          reference
            "ITU-T Recommendation M.3100:
              Generic network information model
            ITU-T Recommendation M.3160:
              Generic, protocol-neutral management information model";

          leaf-list severity-level {
            type severity;
            ordered-by user;
            description
              "Specifies the configured severity level(s) for the
matching alarm.  If the alarm has several severity
levels, the leaf-list shall be given in rising severity
order.  The original M3100/M3160 ASAP function only
allows for a one-to-one mapping between alarm type and
severity, but since YANG module supports stateful
alarms, the mapping must allow for several severity
levels.

Assume a high-utilization alarm type with two thresholds
with the system-default severity levels of threshold1 =
warning and threshold2 = minor.  Setting this leaf-list
to (minor, major) will assign the severity levels as
threshold1 = minor and threshold2 = major";
          }
        }  // container alarm-severity-assignment-profile
      }  // list alarm-profile
    }  // container alarms

    notification alarm-notification {
      description
        "This notification is used to report a state change for an
alarm.  The same notification is used for reporting a newly
raised alarm, a cleared alarm, or changing the text and/or
severity of an existing alarm.";
      leaf resource {
        type resource;
        mandatory true;
        description
          "The alarming resource.  See also 'alt-resource'.  This could
be, for example, a reference to the alarming interface";
      }

      leaf alarm-type-id {
        type alarm-type-id;
        mandatory true;
        description
          "This leaf and the leaf 'alarm-type-qualifier' together
provide a unique identification of the alarm type.";
      }

      leaf alarm-type-qualifier {
        type alarm-type-qualifier;
        description
          "This leaf is used when the 'alarm-type-id' leaf cannot
uniquely identify the alarm type.  Normally, this is not the
case, and this leaf is the empty string.";
      }

      leaf-list alt-resource {
        type resource;
        description
          "Used if the alarming resource is available over other
interfaces.  This field can contain SNMP OIDs, CIM paths, or
3GPP distinguished names, for example.";
      }

      list related-alarm {
        if-feature alarm-correlation;
        key "resource alarm-type-id alarm-type-qualifier";
        description
          "References to related alarms.  Note that the related alarm
might have been purged from the alarm list.";
        leaf resource {
          type leafref {
            path "/alarms/alarm-list/alarm/resource";
            require-instance false;
          }
          description
            "The alarming resource for the related alarm.";
        }

        leaf alarm-type-id {
          type leafref {
            path "/alarms/alarm-list/alarm[resource=current()/../resource]/alarm-type-id";
            require-instance false;
          }
          description
            "The alarm type identifier for the related alarm.";
        }

        leaf alarm-type-qualifier {
          type leafref {
            path "/alarms/alarm-list/alarm[resource=current()/../resource][alarm-type-id=current()/../alarm-type-id]/alarm-type-qualifier";
            require-instance false;
          }
          description
            "The alarm qualifier for the related alarm.";
        }
      }  // list related-alarm

      leaf-list impacted-resource {
        if-feature service-impact-analysis;
        type resource;
        description
          "Resources that might be affected by this alarm.  If the
system creates an alarm on a resource and also has a mapping
to other resources that might be impacted, these resources
can be listed in this leaf-list.  In this way, the system
can create one alarm instead of several.  For example, if an
interface has an alarm, the 'impacted-resource' can
reference the aggregated port channels.";
      }

      leaf-list root-cause-resource {
        if-feature root-cause-analysis;
        type resource;
        description
          "Resources that are candidates for causing the alarm.  If the
system has a mechanism to understand the candidate root
causes of an alarm, this leaf-list can be used to list the
root-cause candidate resources.  In this way, the system can
create one alarm instead of several.  An example might be a
logging system (alarm resource) that fails; the alarm can
reference the file system in the 'root-cause-resource'
leaf-list.  Note that the intended use is not to also send
an alarm with the 'root-cause-resource' as an alarming
resource.  The 'root-cause-resource' leaf-list is a hint and
should not also generate an alarm for the same problem.";
      }

      leaf time {
        type yang:date-and-time;
        mandatory true;
        description
          "The time the status of the alarm changed.  The value
represents the time the real alarm-state change appeared in
the resource and not when it was added to the alarm
list.  The /alarm-list/alarm/last-changed MUST be set to the
same value.";
      }

      leaf perceived-severity {
        type severity-with-clear;
        mandatory true;
        description
          "The severity of the alarm as defined by X.733.  Note that
this may not be the original severity since the alarm may
have changed severity.";
        reference
          "ITU-T Recommendation X.733: Information Technology
            - Open Systems Interconnection
            - System Management: Alarm Reporting Function";

      }

      leaf alarm-text {
        type alarm-text;
        mandatory true;
        description
          "A user-friendly text describing the alarm-state change.";
        reference
          "ITU-T Recommendation X.733: Information Technology
            - Open Systems Interconnection
            - System Management: Alarm Reporting Function";

      }

      leaf event-type {
        type event-type;
        description
          "The X.733/X.736 event type for this alarm.";
      }

      leaf probable-cause {
        type uint32;
        description
          "The X.733 probable cause for this alarm.";
      }

      leaf probable-cause-string {
        type string;
        description
          "The user-friendly string matching
the probable cause integer value.  The string
SHOULD match the X.733 enumeration.  For example,
value 27 is 'localNodeTransmissionError'.";
      }

      container threshold-information {
        description
          "This parameter shall be present when the alarm
is a result of crossing a threshold. ";
        leaf triggered-threshold {
          type string;
          description
            "The identifier of the threshold attribute that
caused the notification.";
        }

        leaf observed-value {
          type value-type;
          description
            "The value of the gauge or counter that crossed
the threshold.  This may be different from the
threshold value if, for example, the gauge may
only take on discrete values.";
        }

        choice threshold-level {
          description
            "In the case of a gauge, the threshold level specifies
a pair of threshold values: the first is the value
of the crossed threshold, and the second is its
corresponding hysteresis; in the case of a counter,
the threshold level specifies only the threshold
value.";
          case up {
            leaf up-high {
              type value-type;
              description
                "The going-up threshold for raising the alarm.";
            }

            leaf up-low {
              type value-type;
              description
                "The going-down threshold for clearing the alarm.
This is used for hysteresis functions for gauges.";
            }
          }  // case up

          case down {
            leaf down-low {
              type value-type;
              description
                "The going-down threshold for raising the alarm.";
            }

            leaf down-high {
              type value-type;
              description
                "The going-up threshold for clearing the alarm.
This is used for hysteresis functions for gauges.";
            }
          }  // case down
        }  // choice threshold-level

        leaf arm-time {
          type yang:date-and-time;
          description
            "For a gauge threshold, it's the time at which the
threshold was last re-armed; namely, it's the time after
the previous threshold crossing at which the hysteresis
value of the threshold was exceeded, thus again permitting
the generation of notifications when the threshold is
crossed.  For a counter threshold, it's the later of the
time at which the threshold offset was last applied or the
counter was last initialized (for resettable counters).";
        }
      }  // container threshold-information

      list monitored-attributes {
        key "id";
        description
          "The Monitored attributes parameter, when present, defines
one or more attributes of the resource and their
corresponding values at the time of the alarm.";
        leaf id {
          type resource;
          description
            "The resource representing the attribute.";
        }

        leaf value {
          type string;
          description
            "The value represented as a string since it could
be of any type.";
        }
      }  // list monitored-attributes

      leaf-list proposed-repair-actions {
        type string;
        description
          "This parameter, when present, is used if the cause is
known and the system being managed can suggest one or
more solutions (such as switch in standby equipment,
retry, and replace media).";
      }

      leaf trend-indication {
        type trend;
        description
          "This parameter specifies the current severity
trend of the resource.  If present, it indicates
that there are one or more alarms ('outstanding
alarms') that have not been cleared and that
pertain to the same resource as this alarm
('current alarm') does.  The possible values are:

  more-severe: The Perceived severity in the current
    alarm is higher (more severe) than that reported in
    any of the outstanding alarms.

  no-change: The Perceived severity reported in the
    current alarm is the same as the highest (most severe)
    of any of the outstanding alarms.

  less-severe: There is at least one outstanding alarm
    of a severity higher (more severe) than that in the
    current alarm.";
      }

      leaf backedup-status {
        type boolean;
        description
          "This parameter, when present, specifies whether or not the
object emitting the alarm has been backed up; therefore, it
is possible to know whether or not services provided to the
user have been disrupted when this parameter is included.
The use of this field in conjunction with the
'perceived-severity' field provides information in an
independent form to qualify the seriousness of the alarm and
the ability of the system as a whole to continue to provide
services.  If the value of this parameter is true, it
indicates that the object emitting the alarm has been backed
up; if false, the object has not been backed up.";
      }

      leaf backup-object {
        type resource;
        description
          "This parameter SHALL be present when the 'backedup-status'
parameter is present and has the value 'true'.  This
parameter specifies the managed object instance that is
providing back-up services for the managed object to which
the notification pertains.  This parameter is useful, for
example, when the back-up object is from a pool of objects,
any of which may be dynamically allocated to replace a
faulty object.";
      }

      list additional-information {
        key "identifier";
        description
          "This parameter allows the inclusion of an additional
information set in the alarm.  It is a series of data
structures, each of which contains three items of
information: an identifier, a significance indicator,
and the problem information.";
        leaf identifier {
          type string;
          description
            "Identifies the data type of the information parameter.";
        }

        leaf significant {
          type boolean;
          description
            "Set to 'true' if the receiving system must be able to
parse the contents of the information subparameter
for the event report to be fully understood.";
        }

        leaf information {
          type string;
          description
            "Additional information about the alarm.";
        }
      }  // list additional-information

      leaf security-alarm-detector {
        type resource;
        description
          "This parameter identifies the detector of the security
alarm.";
      }

      leaf service-user {
        type resource;
        description
          "This parameter identifies the service-user whose request
for service led to the generation of the security alarm.";
      }

      leaf service-provider {
        type resource;
        description
          "This parameter identifies the intended service-provider
of the service that led to the generation of the security
alarm.";
      }
    }  // notification alarm-notification

    notification alarm-inventory-changed {
      description
        "This notification is used to report that the list of possible
alarms has changed.  This can happen when, for example, a new
software module is installed or a new physical card is
inserted.";
    }  // notification alarm-inventory-changed
  }  // module ietf-alarms