module Cisco-IOS-XR-sysadmin-fm {

    yang-version 1;

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

    prefix fm;

    import ietf-yang-types {
      prefix yang;
    }
    import Cisco-IOS-XR-sysadmin-types {
      prefix calvados;
    }
    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.
     
     Fault management YANG model.
     
     Copyright (c) 2014-2020 by Cisco Systems, Inc.
     All rights reserved.";

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

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

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

    semver:module-version "1.0.0";

    typedef fm_fault_state_t {
      type enumeration {
        enum "SET" {
          value 0;
        }
        enum "CLEAR" {
          value 1;
        }
        enum "INFO" {
          value 2;
        }
        enum "INVALID" {
          value 3;
        }
        enum "PARTIALLY_QUALIFIED" {
          value 4;
        }
        enum "SOAKING_BEFORE_SET" {
          value 5;
        }
        enum "SOAKING_BEFORE_CLEAR" {
          value 6;
        }
        enum "SUPPRESSED" {
          value 7;
        }
        enum "UPDATE" {
          value 8;
        }
      }
      description
        "The status value for a given fault condition.";
    }

    typedef fm_fault_severity_t {
      type enumeration {
        enum "CRITICAL" {
          value 0;
        }
        enum "MAJOR" {
          value 1;
        }
        enum "MINOR" {
          value 2;
        }
        enum "NR" {
          value 3;
        }
      }
    }

    typedef fm_action_t {
      type enumeration {
        enum "ISOLATION" {
          value 0;
        }
        enum "MITIGATION" {
          value 1;
        }
        enum "RECOVERY" {
          value 2;
        }
        enum "CORRELATION" {
          value 3;
        }
        enum "ALARM" {
          value 4;
        }
        enum "REPORT" {
          value 5;
        }
      }
      description
        "The List of supported Action Types";
    }

    typedef fm_action_result_t {
      type enumeration {
        enum "SUCCESS" {
          value 0;
        }
        enum "FAILURE" {
          value 1;
        }
        enum "NO-OP" {
          value 2;
        }
      }
      description
        "The result of a certain fm action";
    }

    typedef fm_rule_eval_result_t {
      type enumeration {
        enum "SUCCESS" {
          value 0;
        }
        enum "FAILURE" {
          value 1;
        }
      }
      description
        "The result status of the evaluation of a FM rule.";
    }

    typedef fm_ha_role_t {
      type calvados:generic-ha-role;
      description
        "The HA role for the FM entity";
    }

    typedef fm_location_t {
      type string;
      description
        "The location if the fm entity";
    }

    typedef fm_object_id_t {
      type string;
      description
        "The object id of the fm entity";
    }

    typedef fm_agent_id_t {
      type string;
      description
        "A type for identifying a fault agent.";
    }

    typedef fm_correlation_obj_qualifier_t {
      type enumeration {
        enum "QUALIFIER_IGNORED" {
          value 0;
        }
        enum "QUALIFIER_RACK" {
          value 1;
        }
        enum "QUALIFIER_SLOT" {
          value 2;
        }
        enum "QUALIFIER_OBJECT" {
          value 3;
        }
      }
    }

    typedef fm_history_state_t {
      type enumeration {
        enum "FM_HISTORY_STATE_ACTIVE" {
          value 0;
        }
        enum "FM_HISTORY_STATE_CLEARED" {
          value 1;
        }
        enum "FM_HISTORY_STATE_INVALID" {
          value 2;
        }
      }
      description
        "The fm history entry state.";
    }

    typedef fm_timestamp_t {
      type yang:date-and-time;
      description
        "The fm timestamp type for all times in fm";
    }

    typedef fm_service_scope_t {
      type enumeration {
        enum "FM_SERVICE_NODE_SCOPE" {
          value 0;
        }
        enum "FM_SERVICE_RACK_SCOPE" {
          value 1;
        }
        enum "FM_SERVICE_SYSTEM_SCOPE" {
          value 2;
        }
      }
      description
        "The fm service scope definting type.";
    }

    grouping fm_fault_id_t {
      description
        "A grouping that uniquely indentifies a fault";
      leaf fm_subsystem_id {
        type string;
        description
          "Fault sub-system identifier";
      }

      leaf fm_fault_type {
        type string;
        description "Fault type identifier";
      }

      leaf fm_fault_tag {
        type string;
        description "Fault tag identifier";
      }
    }  // grouping fm_fault_id_t

    grouping fm_fault_pending_info_t {
      description
        "Models data that could eventually cause a new fault";
      uses fm_fault_id_t;

      leaf object_id {
        type fm_object_id_t;
        description
          "The object Id of the entity that generated the fault.";
      }

      leaf fault_timestamp {
        type fm_timestamp_t;
        description
          "The timestamp at which the fault occurred.";
      }

      leaf fault_state {
        type fm_fault_state_t;
        description
          "The state pf tje causal fault.";
      }

      leaf fault_count {
        type uint64;
        description
          "Count of occurrence of the fault event.";
      }

      leaf fault_flag {
        type uint64;
        description
          "FM correlation engine flag, internal.";
      }
    }  // grouping fm_fault_pending_info_t

    grouping fm_fault_action_t {
      description
        "Type to model the fm fault actions.";
      leaf common_action {
        type uint16;
        description "Common action data";
      }

      leaf opaque_action {
        type uint16;
        description "opaque action data";
      }
    }  // grouping fm_fault_action_t

    grouping fm_opaque_data_t {
      description
        "A model for a array of data bytes, opaque to FM";
      leaf opaque_data_len {
        type uint16;
        description
          "The length of opaque data bytes.";
      }
    }  // grouping fm_opaque_data_t

    grouping fm_fault_data_t {
      description
        "A type that collects all the fault related data.";
      leaf fault_object_id {
        type fm_object_id_t;
        description
          "The object Id of the entity that generated the fault.";
      }

      leaf fault_state {
        type fm_fault_state_t;
        description
          "The state of the fault.";
      }

      leaf fault_severity {
        type fm_fault_severity_t;
        description
          "The severity of the fault reported out";
      }

      leaf fault_opaque_action {
        type uint16;
        description
          "Opaque action performed on the fault";
      }

      uses fm_opaque_data_t;

      leaf fault_action_result {
        type fm_action_result_t;
        description "Action result";
      }
    }  // grouping fm_fault_data_t

    grouping fm_init_info_t {
      description
        "A FM instance initialization info.";
      leaf levm {
        type uint64;
        description
          "The levm pointer supplied to fm infra.";
      }

      leaf comp_id {
        type uint32;
        description "The owner component Id";
      }

      leaf process {
        type string;
        description
          "The name of the process in which this fm instance is active.";
      }

      leaf default_rule_cb {
        type uint64;
        description
          "Default rule callback pointer.";
      }

      leaf default_action_cb {
        type uint64;
        description
          "Default action callback pointer.";
      }

      leaf default_notif_cb {
        type uint64;
        description
          "Default notification callback pointer.";
      }

      leaf default_error_cb {
        type uint64;
        description
          "Default error callback pointer.";
      }

      leaf replica_cb {
        type uint64;
        description
          "Data Replica callback pointer.";
      }
    }  // grouping fm_init_info_t

    grouping fm_traversal_t {
      description
        "A type that captures a fault traversal info";
      uses fm_fault_id_t;

      leaf remote_agent_id {
        type fm_agent_id_t;
        description
          "The remote agent id assocaited with this fault.";
      }
    }  // grouping fm_traversal_t

    grouping fm_fault_rule_t {
      description
        "A type associated with a fault rule";
      leaf fault_location {
        type fm_location_t;
        description
          "The location associated with the fault";
      }

      leaf rule_cb {
        type uint64;
        description
          "The callback function that declares the fault";
      }
    }  // grouping fm_fault_rule_t

    grouping fm_fault_entry_history_record_basic_t {
      description
        "A type that captures the basic data of a fault";
      leaf fault_timestamp {
        type fm_timestamp_t;
        description
          "The fault occurence timestamp";
      }

      leaf object_id {
        type string;
        description "The fault object ID";
      }
    }  // grouping fm_fault_entry_history_record_basic_t

    grouping fm_fault_entry_history_record_detail_t {
      description
        "A type that captures the details of a reported fault";
      uses fm_fault_id_t;

      leaf object_id {
        type string;
        description "The fault object ID";
      }

      leaf fault_severity {
        type uint16;
        description
          "The severity of the fault reported out";
      }

      leaf fault_state {
        type fm_fault_state_t;
        description
          "The state of the fault.";
      }

      leaf fault_agent_id {
        type fm_agent_id_t;
        description
          "The agent id associated with the fault";
      }

      leaf fault_timestamp {
        type fm_timestamp_t;
        description
          "The fault occurence timestamp";
      }

      leaf fault_timer_state {
        type boolean;
        description
          "The state of the timer associated with this fault";
      }

      leaf fault_processed {
        type boolean;
        description "The fault is acted on";
      }

      leaf mitigation_result {
        type fm_action_result_t;
        description
          "The result of the mitigation action on the fault.";
      }

      leaf recovery_result {
        type fm_action_result_t;
        description
          "The result of the recovery action on the fault.";
      }

      leaf correlation_result {
        type fm_action_result_t;
        description
          "The result of the correlation action on the fault.";
      }

      leaf alarm_result {
        type fm_action_result_t;
        description
          "The result of the alarm action on the fault.";
      }

      leaf default_result {
        type fm_action_result_t;
        description
          "The result of the default action on the fault.";
      }

      uses fm_opaque_data_t;

      leaf occurrence_count {
        type uint64;
        description
          "The occurrence count of the fault";
      }

      leaf history_state {
        type fm_history_state_t;
        description
          "The history state of the fault.";
      }
    }  // grouping fm_fault_entry_history_record_detail_t

    grouping fm_fault_table_basic_entry_t {
      uses fm_fault_id_t;

      leaf name {
        type string;
        description
          "A descriptive name for the fault";
      }
    }  // grouping fm_fault_table_basic_entry_t

    grouping fm_fault_table_detail_entry_t {
      uses fm_fault_id_t;

      leaf name {
        type string;
        description
          "A descriptive name for the fault";
      }

      leaf description {
        type string;
        description
          "Description of the fault";
      }

      leaf detection_logic {
        type string;
        description "Fault detection logic";
      }

      leaf corr_obj_qualifier {
        type fm_correlation_obj_qualifier_t;
        description
          "The qualifier for the object used for correlation.";
      }
    }  // grouping fm_fault_table_detail_entry_t

    grouping fm_fault_table_internal_entry_t {
      description
        "Grouping of internal fields of a fault table entry.";
      uses fm_fault_id_t;

      list rules {
        description
          "list of fault rule declaring callbacks";
        uses fm_fault_rule_t;
      }  // list rules

      uses fm_fault_action_t;

      leaf mitigation_cb {
        type uint64;
        description
          "Pointer to the mitigation callback function.";
      }

      leaf recovery_cb {
        type uint64;
        description
          "Pointer to the recovery callback function.";
      }

      leaf alarm_severity_dirty {
        type boolean;
        description
          "Flag indicates if alarm severity is dirty";
      }

      leaf disable_action {
        type boolean;
        description
          "Flag indicates all actions are disabled.";
      }

      leaf repeat_action {
        type boolean;
        description
          "Flag indicates all actions are repeated.";
      }

      leaf has_causal_list {
        type boolean;
        description
          "Flag indicates if causal list is present.";
      }

      leaf parser_tag {
        type uint64;
        description
          "The parser tag of the XML parser.";
      }

      leaf parser_tag_string {
        type string;
        description "The parser tag string.";
      }
    }  // grouping fm_fault_table_internal_entry_t

    grouping fm_fault_table_alarm_entry_t {
      description
        "Alarm attributes associated with a fault table entry";
      uses fm_fault_id_t;

      leaf alarm_group {
        type uint16;
        description
          "The alarm grouping for this fault.";
      }

      leaf alarm_severity {
        type uint16;
        description
          "The alarm severity for this fault.";
      }
    }  // grouping fm_fault_table_alarm_entry_t

    grouping fm_fault_table_stats_entry_t {
      uses fm_fault_id_t;

      leaf threshold_count {
        type uint32;
        description
          "Threshold count for the fault";
      }

      leaf all_object_occur_count {
        type uint32;
        description
          "Object occurrence count.";
      }

      leaf declared_count {
        type uint32;
        description
          "Number of times the fault is declared.";
      }

      leaf cleared_count {
        type uint32;
        description
          "Number of times the fault is cleared.";
      }

      leaf info_count {
        type uint32;
        description
          "Number of times the fault is info.";
      }

      leaf hold_time {
        type uint32;
        description
          "The hold time in ms for soaking the fault.";
      }
    }  // grouping fm_fault_table_stats_entry_t

    container fm {
      config false;
      description
        "Sysadmin fault management operational data model";
      list agents {
        key "location process subsystem agent";
        leaf location {
          type string;
        }

        leaf process {
          type string;
        }

        leaf subsystem {
          type string;
        }

        leaf agent {
          type string;
        }

        container fm_initials {
          uses fm_init_info_t;
        }  // container fm_initials

        container fm_table {
          list brief {
            key "fm_subsystem_id fm_fault_type fm_fault_tag";
            uses fm_fault_table_basic_entry_t;
          }  // list brief

          list entry {
            key "fm_subsystem_id fm_fault_type fm_fault_tag";
            uses fm_fault_id_t;

            container detail {
              uses fm_fault_table_detail_entry_t;
            }  // container detail

            list causal_list {
              key "fm_subsystem_id fm_fault_type fm_fault_tag";
              description
                "Causal list of fault ids for the specified fault.";
              uses fm_fault_id_t;
            }  // list causal_list

            list dependency_list {
              key "fm_subsystem_id fm_fault_type fm_fault_tag";
              description
                "Dependency list of fault ids.";
              uses fm_fault_id_t;
            }  // list dependency_list

            list propagation_list {
              key "fm_subsystem_id fm_fault_type fm_fault_tag";
              description
                "Propagation list of fault agents.";
              uses fm_traversal_t;
            }  // list propagation_list

            list notification_list {
              key "fm_subsystem_id fm_fault_type fm_fault_tag";
              description
                "Notification list of fault agents.";
              uses fm_traversal_t;
            }  // list notification_list

            list escalation_list {
              key "fm_subsystem_id fm_fault_type fm_fault_tag";
              description
                "escalation list of fault agents.";
              uses fm_traversal_t;
            }  // list escalation_list

            container faults {
              container active {
                list brief {
                  key "object_id";
                  uses fm_fault_entry_history_record_basic_t;
                }  // list brief

                list detail {
                  key "object_id";
                  uses fm_fault_entry_history_record_detail_t;
                }  // list detail
              }  // container active

              container history {
                list brief {
                  key "object_id";
                  uses fm_fault_entry_history_record_basic_t;
                }  // list brief

                list detail {
                  key "object_id";
                  uses fm_fault_entry_history_record_detail_t;
                }  // list detail
              }  // container history
            }  // container faults

            container waiting_list {
              list brief {
                key "fm_subsystem_id fm_fault_type fm_fault_tag";
                uses fm_fault_pending_info_t;
              }  // list brief

              list entry {
                key "fm_subsystem_id fm_fault_type fm_fault_tag";
                uses fm_fault_pending_info_t;
              }  // list entry
            }  // container waiting_list
          }  // list entry
        }  // container fm_table

        container fm_internals {
          list detail {
            key "fm_subsystem_id fm_fault_type fm_fault_tag";
            uses fm_fault_table_internal_entry_t;
          }  // list detail
        }  // container fm_internals

        container fm_alarm_mapping {
          list detail {
            key "fm_subsystem_id fm_fault_type fm_fault_tag";
            uses fm_fault_table_alarm_entry_t;
          }  // list detail
        }  // container fm_alarm_mapping

        container fm_statistics {
          list detail {
            key "fm_subsystem_id fm_fault_type fm_fault_tag";
            uses fm_fault_table_stats_entry_t;
          }  // list detail
        }  // container fm_statistics
      }  // list agents
    }  // container fm
  }  // module Cisco-IOS-XR-sysadmin-fm