module Cisco-IOS-XR-sysadmin-alarm-mgr {

    yang-version 1;

    namespace
      "http://www.cisco.com/ns/yang/Cisco-IOS-XR-sysadmin-alarm-mgr";

    prefix alarms;

    import ietf-yang-types {
      prefix yang;
    }
    import Cisco-IOS-XR-sysadmin-types {
      prefix calvados;
    }
    import Cisco-IOS-XR-sysadmin-show-trace {
      prefix show_trace;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG
     definitions for Cisco IOS-XR SysAdmin configuration.
     
     Alarm management YANG model
     
     Copyright (c) 2011-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-12-02" {
      description
        "PTAH support for Fibre Channel controller
       2020-09-02
         rackid type change from uint32 to string";
    }

    revision "2019-06-28" {
      description
        "PTAH support for CPRI controller in Felidae 5G platform";
    }

    revision "2019-04-15" {
      description
        "Establish semantic version baseline.";
    }

    revision "2018-04-09" {
      description
        "Required changes for ConfD 6.4.5";
    }

    revision "2017-04-12" {
      description
        "Changed the namespace and module name";
    }

    revision "2012-03-27" {
      description "Initial Revision";
    }

    semver:module-version "3.0.0";
    semver:module-version "2.0.0";
    semver:module-version "2.0.0";

    typedef severity_td {
      type enumeration {
        enum "unknown" {
          value 0;
        }
        enum "not_reported" {
          value 1;
        }
        enum "not_alarmed" {
          value 2;
        }
        enum "minor" {
          value 3;
        }
        enum "major" {
          value 4;
        }
        enum "critical" {
          value 5;
        }
      }
      description
        "The severity enumeration type of an alarm ";
    }

    typedef status_td {
      type enumeration {
        enum "unknown" {
          value 0;
        }
        enum "set" {
          value 1;
        }
        enum "clear" {
          value 2;
        }
        enum "suppress" {
          value 3;
        }
      }
      description
        "The status enumeration type of an alarm ";
    }

    typedef group_td {
      type enumeration {
        enum "unknown" {
          value 0;
        }
        enum "environ" {
          value 1;
        }
        enum "ethernet" {
          value 2;
        }
        enum "fabric" {
          value 3;
        }
        enum "power" {
          value 4;
        }
        enum "software" {
          value 5;
        }
        enum "slice" {
          value 7;
        }
        enum "cpu" {
          value 8;
        }
        enum "controller" {
          value 9;
        }
        enum "sonet" {
          value 10;
        }
        enum "otn" {
          value 11;
        }
        enum "sdh_controller" {
          value 12;
        }
        enum "asic" {
          value 13;
        }
        enum "fpd_infra" {
          value 14;
        }
        enum "shelf" {
          value 15;
        }
        enum "mpa" {
          value 16;
        }
        enum "ots" {
          value 17;
        }
        enum "timing" {
          value 18;
        }
        enum "cpri" {
          value 19;
        }
        enum "fibre_channel" {
          value 20;
        }
        enum "last" {
          value 21;
        }
      }
      description
        "The group enumeration type of an alarm ";
    }

    typedef agent_state_td {
      type enumeration {
        enum "start" {
          value 0;
        }
        enum "init" {
          value 1;
        }
        enum "connecting" {
          value 2;
        }
        enum "connected" {
          value 3;
        }
        enum "registered" {
          value 4;
        }
        enum "disconnected" {
          value 5;
        }
      }
    }

    typedef agent_type_td {
      type enumeration {
        enum "unknown" {
          value 0;
        }
        enum "producer" {
          value 1;
        }
        enum "consumer" {
          value 2;
        }
        enum "subscriber" {
          value 3;
        }
      }
    }

    typedef timestamp_td {
      type yang:date-and-time;
      description
        "The Alarm timestamp type for all times in alarm";
    }

    grouping alarmBasicFilters {
      leaf aid {
        type string;
        description
          "The AID for the current alarm";
      }

      leaf tag {
        type string;
        description
          "The Fault Tag for the current alarm";
      }

      leaf module {
        type string;
        description
          "The Module for the current alarm";
      }

      leaf gen_location {
        type string;
        description
          "The location for the current alarm";
      }

      leaf eid {
        type string;
        description
          "The Object Id for the current alarm";
      }

      leaf severity {
        type severity_td;
        description "The alarm severity.";
      }

      leaf group {
        type group_td;
        description "The alarm grouping ";
      }

      leaf description {
        type string;
        description "Alarm description";
      }

      leaf set_time {
        type string;
        description "Alarm set time stamp";
      }
    }  // grouping alarmBasicFilters

    grouping alarmBasicHistoryFilters {
      leaf clear_time {
        type string;
        description "Alarm clear time stamp";
      }
    }  // grouping alarmBasicHistoryFilters

    grouping alarmBasicSuppressedFilters {
      leaf suppressed_time {
        type string;
        description
          "Alarm suppressed time stamp";
      }
    }  // grouping alarmBasicSuppressedFilters

    grouping alarmExtFilters {
      leaf state {
        type status_td;
        description
          "The current state of the bi-state alarm";
      }

      leaf reporting_agent_id {
        type uint32;
        description
          "The reporting agent id.";
      }

      leaf resynced {
        type uint32;
        description
          "The condition bit-flags of the alarm";
      }

      leaf detail_desc {
        type string;
        description
          "Alarm detailed description";
      }
    }  // grouping alarmExtFilters

    grouping alarmFilters {
      description
        "Alarm attributes that can be used to filter.";
      uses alarmBasicFilters;

      uses alarmExtFilters;

      uses alarmBasicHistoryFilters;
    }  // grouping alarmFilters

    grouping alarmDetailSuppressedFilters {
      description
        "Suppressed alarm detail attributes that can be used to filter.";
      uses alarmBasicFilters;

      uses alarmExtFilters;

      uses alarmBasicSuppressedFilters;
    }  // grouping alarmDetailSuppressedFilters

    grouping alarmBriefFilters {
      description
        "Alarm brief attributes that can be used to filter.";
      uses alarmBasicFilters;

      uses alarmBasicHistoryFilters;
    }  // grouping alarmBriefFilters

    grouping alarmBriefActiveFilters {
      description
        "Alarm brief attributes that can be used to filter.";
      uses alarmBasicFilters;
    }  // grouping alarmBriefActiveFilters

    grouping alarmBriefSuppressedFilters {
      description
        "Suppressed alarm brief attributes that can be used to filter.";
      uses alarmBasicFilters;

      uses alarmBasicSuppressedFilters;
    }  // grouping alarmBriefSuppressedFilters

    grouping alarmStats {
      description "Alarm Statistics.";
      leaf attime {
        type string;
        description
          "Alarms statistics at specified time";
      }

      leaf reported {
        type uint64;
        description
          "Total alarms reported into this service.";
      }

      leaf dropped {
        type uint64;
        description
          "Alarms dropped due to some error or other.";
      }

      leaf bi_set {
        type uint64;
        description
          "Total active alarms current in this service.";
      }

      leaf bi_clear {
        type uint64;
        description
          "Alarms that are currently in the cleared state.";
      }

      leaf suppressed {
        type uint64;
        description
          "Alarms that are currently in the suppressed state.";
      }

      leaf drop_inv_aid {
        type uint64;
        description
          "Alarms dropped due to invalid aid in the alarm report.";
      }

      leaf drop_no_mem {
        type uint64;
        description
          "Alarms dropped due to low memory condition.";
      }

      leaf drop_db_error {
        type uint64;
        description
          "Alarms dropped due to database internal error.";
      }

      leaf drop_clear_no_set {
        type uint64;
        description
          "Alarms dropped due to clear without a set.";
      }

      leaf drop_dup {
        type uint64;
        description
          "Alarms dropped due to duplicate alarm report.";
      }

      leaf cache_hit {
        type uint64;
        description
          "Alarms present in the cached for show";
      }

      leaf cache_miss {
        type uint64;
        description
          "Alarms not present in the cached for show";
      }
    }  // grouping alarmStats

    grouping alarmClients {
      description "Alarm clients.";
      leaf agent_name {
        type string;
        description "Alarms client";
      }

      leaf agent_id {
        type uint32;
        description
          "Alarms agent id of the client";
      }

      leaf agent_location {
        type string;
        description
          "The location of this client";
      }

      leaf agent_handle {
        type string;
        description
          "The client handle through which interface";
      }

      leaf agent_state {
        type agent_state_td;
        description
          "The current state of the client";
      }

      leaf agent_type {
        type agent_type_td;
        description
          "The type of  the client";
      }

      leaf agent_filter_disp {
        type boolean;
        description
          "The current subscription status of the client";
      }

      leaf agent_subs_id {
        type uint32;
        description
          "The subscriber id of the client";
      }

      leaf agent_filter_state {
        type status_td;
        description
          "The filter used for alarm bi-state state";
      }

      leaf agent_filter_severity {
        type severity_td;
        description
          "The filter used for alarm severity";
      }

      leaf agent_filter_group {
        type group_td;
        description
          "The filter used for alarm group";
      }

      leaf agent_sdr_id {
        type uint32;
        description
          "agent alarm_sm register with sdr_id in SOMT mode";
      }

      leaf agent_connect_count {
        type uint64;
        description
          "Number of times the agent connected to the alarm mgr";
      }

      leaf agent_connect_time {
        type string;
        description
          "Agent connect timestamp";
      }

      leaf agent_get_count {
        type uint64;
        description
          "Number of times the agent queried for alarms";
      }

      leaf agent_subscribe_count {
        type uint64;
        description
          "Number of times the agent subscribed for alarms";
      }

      leaf agent_report_count {
        type uint64;
        description
          "Number of times the agent reported alarms";
      }
    }  // grouping alarmClients

    grouping scope_brief_shows {
      list active {
        key "aid eid";
        max-elements 1024;
        uses alarmBriefActiveFilters;
      }  // list active

      list history {
        key "aid eid";
        max-elements 1024;
        uses alarmBriefFilters;
      }  // list history

      list suppressed {
        key "aid eid";
        max-elements 1024;
        uses alarmBriefSuppressedFilters;
      }  // list suppressed
    }  // grouping scope_brief_shows

    grouping scope_detail_shows {
      list active {
        key "aid eid";
        max-elements 1024;
        uses alarmFilters;
      }  // list active

      list history {
        key "aid eid";
        max-elements 1024;
        uses alarmFilters;
      }  // list history

      list stats {
        key "attime";
        max-elements 1024;
        uses alarmStats;
      }  // list stats

      list clients {
        key "agent_handle";
        max-elements 1024;
        uses alarmClients;
      }  // list clients

      list suppressed {
        key "aid eid";
        max-elements 1024;
        uses alarmDetailSuppressedFilters;
      }  // list suppressed
    }  // grouping scope_detail_shows

    container alarm_mgr {
      config false;
      description
        "Calvados alarms operational data model";
      uses show_trace:traceable;

      container brief {
        description
          "A set of brief alarm commands";
        container card {
          description
            "Alarms reported at the local card as
           specified by the location parameter";
          list location {
            key "locations";
            leaf locations {
              type calvados:location-id;
            }

            uses scope_brief_shows;
          }  // list location
        }  // container card

        container rack {
          description
            "Alarms reported at the rack scope
           specified by the rack-id";
          list rack_locations {
            key "rackid";
            leaf rackid {
              type string;
            }

            uses scope_brief_shows;
          }  // list rack_locations
        }  // container rack

        container system {
          description
            "Alarms reported at the system scope";
          uses scope_brief_shows;
        }  // container system
      }  // container brief

      container detail {
        description
          "A set of detail alarm commands";
        container card {
          description
            "Alarms reported at the local card as
           specified by the location parameter";
          list location {
            key "locations";
            leaf locations {
              type calvados:location-id;
            }

            uses scope_detail_shows;
          }  // list location
        }  // container card

        container rack {
          description
            "Alarms reported at the rack as
           specified by the location parameter";
          list rack_locations {
            key "rackid";
            leaf rackid {
              type string;
            }

            uses scope_detail_shows;
          }  // list rack_locations
        }  // container rack

        container system {
          description
            "Alarms reported at the system as
           specified by the location parameter";
          uses scope_detail_shows;
        }  // container system
      }  // container detail
    }  // container alarm_mgr
  }  // module Cisco-IOS-XR-sysadmin-alarm-mgr