module Cisco-IOS-XR-infra-syslog-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-infra-syslog-cfg";

    prefix infra-syslog-cfg;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    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 infra-syslog package configuration.

This module contains definitions
for the following management objects:
  syslog-service: Syslog Timestamp Services
  syslog: Modify message logging facilities

Copyright (c) 2013-2020 by Cisco Systems, Inc.
All rights reserved.";

    revision "2020-05-22" {
      description
        "Support for syslog format types bsd and rfc5424";
    }

    revision "2019-09-30" {
      description
        "Changes done for Openroadm Severity level support";
    }

    revision "2019-07-30" {
      description
        "container ipv4-severity-port changed to presence container";
    }

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

    revision "2017-10-31" {
      description
        "file path option provided in logging file config";
    }

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2016-06-22" {
      description
        "file path removed from logging file config";
    }

    revision "2015-01-07" {
      description "IOS XR 5.3.1 revision.";
    }

    semver:module-version "2.0.0";
    semver:module-version "1.0.1";
    semver:module-version "1.0.0";

    typedef Logging-tos {
      type enumeration {
        enum "precedence" {
          value 0;
          description
            "Logging TOS type precedence";
        }
        enum "dscp" {
          value 1;
          description
            "Logging TOS type DSCP";
        }
      }
      description "Logging tos";
    }

    typedef Logging-dscp-value {
      type union {
        type enumeration {
          enum "default" {
            value 0;
            description
              "Applicable to DSCP: bits 000000";
          }
          enum "af11" {
            value 10;
            description
              "Applicable to DSCP: bits 001010";
          }
          enum "af12" {
            value 12;
            description
              "Applicable to DSCP: bits 001100";
          }
          enum "af13" {
            value 14;
            description
              "Applicable to DSCP: bits 001110";
          }
          enum "af21" {
            value 18;
            description
              "Applicable to DSCP: bits 010010";
          }
          enum "af22" {
            value 20;
            description
              "Applicable to DSCP: bits 010100";
          }
          enum "af23" {
            value 22;
            description
              "Applicable to DSCP: bits 010110";
          }
          enum "af31" {
            value 26;
            description
              "Applicable to DSCP: bits 011010";
          }
          enum "af32" {
            value 28;
            description
              "Applicable to DSCP: bits 011100";
          }
          enum "af33" {
            value 30;
            description
              "Applicable to DSCP: bits 011110";
          }
          enum "af41" {
            value 34;
            description
              "Applicable to DSCP: bits 100010";
          }
          enum "af42" {
            value 36;
            description
              "Applicable to DSCP: bits 100100";
          }
          enum "af43" {
            value 38;
            description
              "Applicable to DSCP: bits 100110";
          }
          enum "ef" {
            value 46;
            description
              "Applicable to DSCP: bits 101110";
          }
          enum "cs1" {
            value 8;
            description
              "Applicable to DSCP: bits 001000";
          }
          enum "cs2" {
            value 16;
            description
              "Applicable to DSCP: bits 010000";
          }
          enum "cs3" {
            value 24;
            description
              "Applicable to DSCP: bits 011000";
          }
          enum "cs4" {
            value 32;
            description
              "Applicable to DSCP: bits 100000";
          }
          enum "cs5" {
            value 40;
            description
              "Applicable to DSCP: bits 101000";
          }
          enum "cs6" {
            value 48;
            description
              "Applicable to DSCP: bits 110000";
          }
          enum "cs7" {
            value 56;
            description
              "Applicable to DSCP: bits 111000";
          }
        }
        type uint32 {
          range "0..63";
        }
      }
      description "Logging dscp value";
    }

    typedef Logging-precedence-value {
      type union {
        type enumeration {
          enum "routine" {
            value 0;
            description
              "Applicable to precedence: value 0";
          }
          enum "priority" {
            value 1;
            description
              "Applicable to precedence: value 1";
          }
          enum "immediate" {
            value 2;
            description
              "Applicable to precedence: value 2";
          }
          enum "flash" {
            value 3;
            description
              "Applicable to precedence: value 3";
          }
          enum "flash-override" {
            value 4;
            description
              "Applicable to precedence: value 4";
          }
          enum "critical" {
            value 5;
            description
              "Applicable to precedence: value 5";
          }
          enum "internet" {
            value 6;
            description
              "Applicable to precedence: value 6";
          }
          enum "network" {
            value 7;
            description
              "Applicable to precedence: value 7";
          }
        }
        type uint32 {
          range "0..7";
        }
      }
      description "Logging precedence value";
    }

    typedef Facility {
      type enumeration {
        enum "kern" {
          value 0;
          description "Kernel Facility";
        }
        enum "user" {
          value 8;
          description "User Facility";
        }
        enum "mail" {
          value 16;
          description "Mail Facility";
        }
        enum "daemon" {
          value 24;
          description "Daemon Facility";
        }
        enum "auth" {
          value 32;
          description "Auth Facility";
        }
        enum "syslog" {
          value 40;
          description "Syslog Facility";
        }
        enum "lpr" {
          value 48;
          description "Lpr Facility";
        }
        enum "news" {
          value 56;
          description "News Facility";
        }
        enum "uucp" {
          value 64;
          description "Uucp Facility";
        }
        enum "cron" {
          value 72;
          description "Cron Facility";
        }
        enum "authpriv" {
          value 80;
          description "Authpriv Facility";
        }
        enum "ftp" {
          value 88;
          description "Ftp Facility";
        }
        enum "local0" {
          value 128;
          description "Local0 Facility";
        }
        enum "local1" {
          value 136;
          description "Local1 Facility";
        }
        enum "local2" {
          value 144;
          description "Local2 Facility";
        }
        enum "local3" {
          value 152;
          description "Local3 Facility";
        }
        enum "local4" {
          value 160;
          description "Local4 Facility";
        }
        enum "local5" {
          value 168;
          description "Local5 Facility";
        }
        enum "local6" {
          value 176;
          description "Local6 Facility";
        }
        enum "local7" {
          value 184;
          description "Local7 Facility";
        }
        enum "sys9" {
          value 192;
          description "System9 Facility";
        }
        enum "sys10" {
          value 200;
          description "System10 Facility";
        }
        enum "sys11" {
          value 208;
          description "System11 Facility";
        }
        enum "sys12" {
          value 216;
          description "System12 Facility";
        }
        enum "sys13" {
          value 224;
          description "System13 Facility";
        }
        enum "sys14" {
          value 232;
          description "System14 Facility";
        }
      }
      description "Facility";
    }

    typedef Logging-dscp {
      type enumeration {
        enum "dscp" {
          value 1;
          description
            "Logging TOS type DSCP";
        }
      }
      description "Logging dscp";
    }

    typedef Logging-levels {
      type enumeration {
        enum "emergency" {
          value 0;
          description "Emergency Level Msg";
        }
        enum "alert" {
          value 1;
          description "Alert Level Msg";
        }
        enum "critical" {
          value 2;
          description "Critical Level Msg";
        }
        enum "error" {
          value 3;
          description "Error Level Msg";
        }
        enum "warning" {
          value 4;
          description "Warning Level Msg";
        }
        enum "notice" {
          value 5;
          description
            "Notification Level Msg";
        }
        enum "info" {
          value 6;
          description
            "Informational Level Msg";
        }
        enum "debug" {
          value 7;
          description "Debugging Level Msg";
        }
        enum "disable" {
          value 15;
          description "Disable logging";
        }
      }
      description "Logging levels";
    }

    typedef Syslog-format {
      type enumeration {
        enum "rfc5424" {
          value 1;
          description
            "Enable to send the syslog message rfc5424
format";
        }
        enum "bsd" {
          value 2;
          description
            "Enable to send the syslog message as BSD format";
        }
      }
      description "Syslog format";
    }

    typedef Logging-precedence {
      type enumeration {
        enum "precedence" {
          value 0;
          description
            "Logging TOS type precedence";
        }
      }
      description "Logging precedence";
    }

    typedef Log-opertor {
      type enumeration {
        enum "equals-or-higher" {
          value 0;
          description
            "Messages equal or higher than severity
(Operator=0)";
        }
        enum "equals" {
          value 1;
          description
            "Messages equal to severity
(Operator=1)";
        }
        enum "not-equals" {
          value 2;
          description
            "Messages not equal to severity
(Operator=2)";
        }
      }
      description "Log opertor";
    }

    typedef Time-info {
      type enumeration {
        enum "disable" {
          value 0;
          description "Exclude";
        }
        enum "enable" {
          value 1;
          description "Include";
        }
      }
      description "Time info";
    }

    typedef Log-message-severity {
      type enumeration {
        enum "emergency" {
          value 0;
          description
            "System is unusable                (severity=0)";
        }
        enum "alert" {
          value 1;
          description
            "Immediate action needed           (severity=1)";
        }
        enum "critical" {
          value 2;
          description
            "Critical conditions               (severity=2)";
        }
        enum "error" {
          value 3;
          description
            "Error conditions                  (severity=3)";
        }
        enum "warning" {
          value 4;
          description
            "Warning conditions                (severity=4)";
        }
        enum "notice" {
          value 5;
          description
            "Normal but significant conditions (severity=5)";
        }
        enum "informational" {
          value 6;
          description
            "Informational messages            (severity=6)";
        }
        enum "debug" {
          value 7;
          description
            "Debugging messages                (severity=7)";
        }
      }
      description "Log message severity";
    }

    typedef Log-collect-frequency {
      type enumeration {
        enum "weekly" {
          value 1;
          description
            "Collect log in files on a weekly basis";
        }
        enum "daily" {
          value 2;
          description
            "Collect log in files on a daily basis";
        }
      }
      description "Log collect frequency";
    }

    typedef Log-severity {
      type enumeration {
        enum "emergency" {
          value 0;
          description
            "System is unusable                (severity=0)";
        }
        enum "alert" {
          value 1;
          description
            "Immediate action needed           (severity=1)";
        }
        enum "critical" {
          value 2;
          description
            "Critical conditions               (severity=2)";
        }
        enum "error" {
          value 3;
          description
            "Error conditions                  (severity=3)";
        }
        enum "warning" {
          value 4;
          description
            "Warning conditions                (severity=4)";
        }
        enum "notice" {
          value 5;
          description
            "Normal but significant conditions (severity=5)";
        }
        enum "informational" {
          value 6;
          description
            "Informational messages            (severity=6)";
        }
        enum "debug" {
          value 7;
          description
            "Debugging messages                (severity=7)";
        }
        enum "all" {
          value 8;
          description
            "All severity messages             (severity=8)";
        }
        enum "none" {
          value 9;
          description
            "None of severity messages         (severity=9)";
        }
      }
      description "Log severity";
    }

    container syslog-service {
      description
        "Syslog Timestamp Services";
      container timestamps {
        description
          "Timestamp debug/log messages configuration";
        container log {
          description
            "Timestamp log messages";
          container log-datetime {
            description
              "Timestamp with date and time";
            container log-datetime-value {
              description
                "Set timestamp for log message";
              leaf time-stamp-value {
                type Time-info;
                default "enable";
                description "Time";
              }

              leaf msec {
                type Time-info;
                units "second";
                default "enable";
                description "Seconds";
              }

              leaf time-zone {
                type Time-info;
                default "disable";
                description "Timezone";
              }

              leaf year {
                type Time-info;
                default "disable";
                description "Year";
              }
            }  // container log-datetime-value
          }  // container log-datetime

          leaf log-uptime {
            type empty;
            description
              "Timestamp with systime uptime";
          }

          leaf log-timestamp-disable {
            type empty;
            description
              "Disable timestamp log messages";
          }
        }  // container log

        container debug {
          description
            "Timestamp debug messages";
          container debug-datetime {
            description
              "Timestamp with date and time";
            container datetime-value {
              description
                "Set time format for debug msg";
              leaf time-stamp-value {
                type Time-info;
                default "enable";
                description "Time";
              }

              leaf msec {
                type Time-info;
                units "second";
                default "enable";
                description "Seconds";
              }

              leaf time-zone {
                type Time-info;
                default "disable";
                description "Timezone";
              }

              leaf year {
                type Time-info;
                default "disable";
                description "Year";
              }
            }  // container datetime-value
          }  // container debug-datetime

          leaf debug-timestamp-disable {
            type empty;
            description
              "Disable timestamp debug messages";
          }

          leaf debug-uptime {
            type empty;
            description
              "Timestamp with systime uptime";
          }
        }  // container debug

        leaf enable {
          type empty;
          description
            "Enable timestamp debug/log messages";
        }
      }  // container timestamps
    }  // container syslog-service

    container syslog {
      description
        "Modify message logging facilities";
      container monitor-logging {
        description "Set monitor logging";
        container monitor-discriminator {
          description
            "Set monitor logging discriminators";
          leaf match2 {
            type string;
            description
              "Set monitor logging match2 discriminator";
          }

          leaf nomatch1 {
            type string;
            description
              "Set monitor logging no-match1 discriminator";
          }

          leaf match1 {
            type string;
            description
              "Set monitor logging match1 discriminator";
          }

          leaf nomatch3 {
            type string;
            description
              "Set monitor logging no-match3 discriminator";
          }

          leaf match3 {
            type string;
            description
              "Set monitor logging match3 discriminator";
          }

          leaf nomatch2 {
            type string;
            description
              "Set monitor logging no-match2 discriminator";
          }
        }  // container monitor-discriminator

        leaf logging-level {
          type Logging-levels;
          default "debug";
          description
            "Monitor Logging Level";
        }
      }  // container monitor-logging

      container history-logging {
        description "Set history logging";
        leaf history-size {
          type uint32 {
            range "1..500";
          }
          default "1";
          description "Logging history size";
        }

        leaf logging-level {
          type Logging-levels;
          default "warning";
          description
            "History logging level";
        }
      }  // container history-logging

      container logging-facilities {
        description
          "Modify message logging facilities";
        leaf facility-level {
          type Facility;
          default "local7";
          description
            "Facility from which logging is done";
        }
      }  // container logging-facilities

      container trap-logging {
        description "Set trap logging";
        leaf logging-level {
          type Logging-levels;
          default "info";
          description "Trap logging level";
        }
      }  // container trap-logging

      container buffered-logging {
        description
          "Set buffered logging parameters";
        container buffered-discriminator {
          description
            "Set buffered logging discriminators";
          leaf match2 {
            type string;
            description
              "Set buffered logging match2 discriminator";
          }

          leaf nomatch1 {
            type string;
            description
              "Set buffered logging no-match1 discriminator";
          }

          leaf match1 {
            type string;
            description
              "Set buffered logging match1 discriminator";
          }

          leaf nomatch3 {
            type string;
            description
              "Set buffered logging no-match3 discriminator";
          }

          leaf match3 {
            type string;
            description
              "Set buffered logging match3 discriminator";
          }

          leaf nomatch2 {
            type string;
            description
              "Set buffered logging no-match2 discriminator";
          }
        }  // container buffered-discriminator

        leaf logging-level {
          type Logging-levels;
          default "debug";
          description
            "Logging level for Buffered logging";
        }

        leaf buffer-size {
          type uint32 {
            range "307200..125000000";
          }
          default "307200";
          description
            "Logging buffered size";
        }
      }  // container buffered-logging

      container host-server {
        description "Configure logging host";
        container vrfs {
          description "VRF table";
          list vrf {
            key "vrf-name";
            description "VRF specific data";
            container ipv6s {
              description
                "List of the IPv6 logging host";
              list ipv6 {
                key "address";
                description
                  "IPv6 address of the logging host";
                container ipv6-severity-port {
                  description
                    "Severity/Port for the logging host";
                  leaf severity {
                    type Log-severity;
                    default "informational";
                    description
                      "Severity for the logging host";
                  }

                  leaf port {
                    type inet:port-number;
                    default "514";
                    description
                      "Port for the logging host";
                  }

                  leaf operator {
                    type Log-opertor;
                    default
                      "equals-or-higher";
                    description
                      "Severity Operator for the logging host";
                  }
                }  // container ipv6-severity-port

                container ipv6-severity-levels {
                  status obsolete;
                  description
                    "Severity container of the logging host";
                  list ipv6-severity-level {
                    key "severity";
                    status obsolete;
                    description
                      "Severity for the logging host";
                    leaf severity {
                      type Log-severity;
                      description
                        "Severity for the logging host";
                    }
                  }  // list ipv6-severity-level
                }  // container ipv6-severity-levels

                leaf address {
                  type inet:ipv6-address-no-zone;
                  description
                    "IPv6 address of the logging host";
                }
              }  // list ipv6
            }  // container ipv6s

            container hosts {
              description
                "List of the logging host";
              list host {
                key "host-name";
                description
                  "Name of the logging host";
                container host-name-severities {
                  status obsolete;
                  description
                    "Severity container of the logging host";
                  list host-name-severity {
                    key "severity";
                    status obsolete;
                    description
                      "Severity for the logging host";
                    leaf severity {
                      type Log-severity;
                      description
                        "Severity for the logging host";
                    }
                  }  // list host-name-severity
                }  // container host-name-severities

                container host-severity-port {
                  description
                    "Severity/Port for the logging host";
                  leaf severity {
                    type Log-severity;
                    default "informational";
                    description
                      "Severity for the logging host";
                  }

                  leaf port {
                    type inet:port-number;
                    default "514";
                    description
                      "Port for the logging host";
                  }

                  leaf operator {
                    type Log-opertor;
                    default
                      "equals-or-higher";
                    description
                      "Severity Operator for the logging host";
                  }
                }  // container host-severity-port

                leaf host-name {
                  type string;
                  description
                    "Name of the logging host";
                }
              }  // list host
            }  // container hosts

            container ipv4s {
              description
                "List of the IPv4 logging host";
              list ipv4 {
                key "address";
                description
                  "IPv4 address of the logging host";
                container ipv4-severity-levels {
                  status obsolete;
                  description
                    "Severity container of the logging host";
                  list ipv4-severity-level {
                    key "severity";
                    status obsolete;
                    description
                      "Severity for the logging host";
                    leaf severity {
                      type Log-severity;
                      description
                        "Severity for the logging host";
                    }
                  }  // list ipv4-severity-level
                }  // container ipv4-severity-levels

                container ipv4-severity-port {
                  presence
                    "enable ipv4-severity-port";
                  description
                    "Severity/Port for the logging host";
                  leaf severity {
                    type Log-severity;
                    default "informational";
                    description
                      "Severity for the logging host";
                  }

                  leaf port {
                    type inet:port-number;
                    default "514";
                    description
                      "Port for the logging host";
                  }

                  leaf operator {
                    type Log-opertor;
                    default
                      "equals-or-higher";
                    description
                      "Severity Operator for the logging host";
                  }
                }  // container ipv4-severity-port

                leaf address {
                  type inet:ipv4-address-no-zone;
                  description
                    "IPv4 address of the logging host";
                }
              }  // list ipv4
            }  // container ipv4s

            leaf vrf-name {
              type xr:Cisco-ios-xr-string;
              description
                "Name of the VRF instance";
            }
          }  // list vrf
        }  // container vrfs
      }  // container host-server

      container console-logging {
        description "Set console logging";
        container console-discriminator {
          description
            "Set console logging discriminators";
          leaf match2 {
            type string;
            description
              "Set console logging match2 discriminator";
          }

          leaf nomatch1 {
            type string;
            description
              "Set console logging no-match1 discriminator";
          }

          leaf match1 {
            type string;
            description
              "Set console logging match1 discriminator";
          }

          leaf nomatch3 {
            type string;
            description
              "Set console logging no-match3 discriminator";
          }

          leaf match3 {
            type string;
            description
              "Set console logging match3 discriminator";
          }

          leaf nomatch2 {
            type string;
            description
              "Set console logging no-match2 discriminator";
          }
        }  // container console-discriminator

        leaf logging-level {
          type Logging-levels;
          default "warning";
          description
            "Console logging level";
        }
      }  // container console-logging

      container files {
        description
          "Configure logging file destination";
        list file {
          key "file-name";
          description "Specify File Name";
          container file-specification {
            description
              "Specifications of the logging file destination";
            leaf path {
              type string;
              description "File path";
            }

            leaf max-file-size {
              type uint32;
              default "1024";
              description
                "Maximum file size (in KB)";
            }

            leaf severity {
              type uint32;
              default "6";
              description
                "Severity of messages";
            }
          }  // container file-specification

          container file-log-discriminator {
            description
              "Set File logging discriminators";
            leaf nomatch2 {
              type string;
              description
                "Set file logging no match discriminator 2";
            }

            leaf match3 {
              type string;
              description
                "Set file logging match discriminator 3";
            }

            leaf nomatch3 {
              type string;
              description
                "Set file logging no match discriminator 3";
            }

            leaf match1 {
              type string;
              description
                "Set file logging match discriminator 1";
            }

            leaf nomatch1 {
              type string;
              description
                "Set file logging no match discriminator 1";
            }

            leaf match2 {
              type string;
              description
                "Set file logging match discriminator 2";
            }
          }  // container file-log-discriminator

          leaf file-name {
            type xr:Cisco-ios-xr-string;
            description "Name of the file";
          }
        }  // list file
      }  // container files

      container ipv4 {
        description
          "Syslog TOS bit for outgoing messages";
        container dscp {
          presence
            "Indicates a dscp node is configured.";
          status obsolete;
          description "DSCP value";
          leaf type {
            type Logging-dscp;
            mandatory true;
            description
              "Logging TOS type DSCP";
          }

          leaf unused {
            type Logging-precedence-value;
            description "Unused";
          }

          leaf value {
            type Logging-dscp-value;
            mandatory true;
            description "Logging DSCP value";
          }
        }  // container dscp

        container tos {
          description "Type of service";
          leaf type {
            type Logging-tos;
            description
              "Logging TOS type DSCP or precedence";
          }

          leaf precedence {
            when "../type = 'precedence'" {
              description
                "../Type = Precedence";
            }
            type Logging-precedence-value;
            description
              "Logging precedence value";
          }

          leaf dscp {
            when "../type = 'dscp'" {
              description "../Type = DSCP";
            }
            type Logging-dscp-value;
            description "Logging DSCP value";
          }
        }  // container tos

        container precedence {
          presence
            "Indicates a precedence node is configured.";
          status obsolete;
          description "Precedence value";
          leaf type {
            type Logging-precedence;
            mandatory true;
            description
              "Logging TOS type precedence";
          }

          leaf value {
            type Logging-precedence-value;
            mandatory true;
            description
              "Logging precedence value";
          }

          leaf unused {
            type Logging-dscp-value;
            description "Unused";
          }
        }  // container precedence
      }  // container ipv4

      container archive {
        description
          "Archive attributes configuration";
        leaf size {
          type uint32 {
            range "1..2047";
          }
          description
            "The total size of the archive";
        }

        leaf file-size {
          type uint32 {
            range "1..2047";
          }
          description
            "The maximum file size for a single log file.";
        }

        leaf device {
          type string;
          description
            "'/disk0:' or '/disk1:' or '/harddisk:'";
        }

        leaf threshold {
          type uint32 {
            range "1..99";
          }
          units "percentage";
          description
            "The size threshold at which a syslog is
generated";
        }

        leaf frequency {
          type Log-collect-frequency;
          description
            "The collection interval for logs";
        }

        leaf severity {
          type Log-message-severity;
          description
            "The minimum severity of log messages to archive";
        }

        leaf length {
          type uint32 {
            range "1..256";
          }
          description
            "The maximum number of weeks of log to maintain";
        }
      }  // container archive

      container ipv6 {
        description
          "Syslog traffic class bit for outgoing messages";
        container dscp {
          presence
            "Indicates a dscp node is configured.";
          status obsolete;
          description "DSCP value";
          leaf type {
            type Logging-dscp;
            mandatory true;
            description
              "Logging TOS type DSCP";
          }

          leaf unused {
            type Logging-precedence-value;
            description "Unused";
          }

          leaf value {
            type Logging-dscp-value;
            mandatory true;
            description "Logging DSCP value";
          }
        }  // container dscp

        container traffic-class {
          description
            "Type of traffic class";
          leaf type {
            type Logging-tos;
            description
              "Logging TOS type DSCP or precedence";
          }

          leaf precedence {
            when "../type = 'precedence'" {
              description
                "../Type = Precedence";
            }
            type Logging-precedence-value;
            description
              "Logging precedence value";
          }

          leaf dscp {
            when "../type = 'dscp'" {
              description "../Type = DSCP";
            }
            type Logging-dscp-value;
            description "Logging DSCP value";
          }
        }  // container traffic-class

        container precedence {
          presence
            "Indicates a precedence node is configured.";
          status obsolete;
          description "Precedence value";
          leaf type {
            type Logging-precedence;
            mandatory true;
            description
              "Logging TOS type precedence";
          }

          leaf value {
            type Logging-precedence-value;
            mandatory true;
            description
              "Logging precedence value";
          }

          leaf unused {
            type Logging-dscp-value;
            description "Unused";
          }
        }  // container precedence
      }  // container ipv6

      container source-interface-table {
        description
          "Configure source interface";
        container source-interface-values {
          description
            "Specify interface for source address in logging
transactions";
          list source-interface-value {
            key "src-interface-name-value";
            description "Source interface";
            container source-interface-vrfs {
              description
                "Configure source interface VRF";
              list source-interface-vrf {
                key "vrf-name";
                description
                  "Specify VRF for source interface";
                leaf vrf-name {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Name of the VRF instance";
                }
              }  // list source-interface-vrf
            }  // container source-interface-vrfs

            leaf src-interface-name-value {
              type xr:Interface-name;
              description "Which Interface";
            }
          }  // list source-interface-value
        }  // container source-interface-values
      }  // container source-interface-table

      leaf logging-format {
        type Syslog-format;
        description
          "Syslog Logging Message Format";
      }

      leaf host-name-prefix {
        type string;
        description
          "Hostname prefix to add on msgs to servers";
      }

      leaf local-log-file-size {
        type uint32 {
          range "0..4294967295";
        }
        default "32768";
        description
          "Set size of the local log file";
      }

      leaf enable-console-logging {
        type boolean;
        description "Enabled or disabled";
      }

      leaf suppress-duplicates {
        type empty;
        description
          "Suppress consecutive duplicate messages";
      }

      container correlator {
        description
          "Configure properties of the event correlator";
        container rules {
          description
            "Table of configured rules";
          list rule {
            key "name";
            description "Rule name";
            container definition {
              description
                "Configure a specified correlation rule";
              leaf timeout {
                type uint32 {
                  range "1..7200000";
                }
                description
                  "Timeout (time the rule is to be active) in
milliseconds";
              }

              leaf category-name-entry1 {
                type string;
                description
                  "Root message category name";
              }

              leaf group-name-entry1 {
                type string;
                description
                  "Root message group name";
              }

              leaf message-code-entry1 {
                type string;
                description
                  "Root message code";
              }

              leaf category-name-entry2 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry2 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry2 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry3 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry3 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry3 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry4 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry4 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry4 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry5 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry5 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry5 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry6 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry6 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry6 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry7 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry7 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry7 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry8 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry8 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry8 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry9 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry9 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry9 {
                type string;
                description
                  "Correlated message code";
              }

              leaf category-name-entry10 {
                type string;
                description
                  "Correlated message category name";
              }

              leaf group-name-entry10 {
                type string;
                description
                  "Correlated message group name";
              }

              leaf message-code-entry10 {
                type string;
                description
                  "Correlated message code";
              }
            }  // container definition

            container non-stateful {
              description
                "The Non-Stateful Rule Type";
              leaf context-correlation {
                type empty;
                description
                  "Enable correlation on alarm context";
              }

              leaf timeout-root-cause {
                type uint32 {
                  range "1..7200000";
                }
                units "millisecond";
                description
                  "Rootcause Timeout (time to wait for rootcause)
in milliseconds";
              }

              container non-root-causes {
                description
                  "Table of configured non-rootcause";
                list non-root-cause {
                  key "category group message-code";
                  description
                    "A non-rootcause";
                  leaf category {
                    type string;
                    description
                      "Correlated message category";
                  }

                  leaf group {
                    type string;
                    description
                      "Correlated message group";
                  }

                  leaf message-code {
                    type string;
                    description
                      "Correlated message code";
                  }
                }  // list non-root-cause
              }  // container non-root-causes

              container root-cause {
                description "The root cause";
                leaf category {
                  type string;
                  description
                    "Root message category";
                }

                leaf group {
                  type string;
                  description
                    "Root message group";
                }

                leaf message-code {
                  type string;
                  description
                    "Root message code";
                }
              }  // container root-cause

              leaf timeout {
                type uint32 {
                  range "1..7200000";
                }
                units "millisecond";
                description
                  "Timeout (time to wait for active correlation) in
milliseconds";
              }
            }  // container non-stateful

            container stateful {
              description
                "The Stateful Rule Type";
              leaf reparent {
                type empty;
                description
                  "Enable reparent of alarm on rootcause alarm
clear";
              }

              leaf reissue {
                type empty;
                description
                  "Enable reissue of non-bistate alarms on
rootcause alarm clear";
              }

              leaf context-correlation {
                type empty;
                description
                  "Enable correlation on alarm context";
              }

              leaf timeout-root-cause {
                type uint32 {
                  range "1..7200000";
                }
                units "millisecond";
                description
                  "Rootcause Timeout (time to wait for rootcause)
in milliseconds";
              }

              container non-root-causes {
                description
                  "Table of configured non-rootcause";
                list non-root-cause {
                  key "category group message-code";
                  description
                    "A non-rootcause";
                  leaf category {
                    type string;
                    description
                      "Correlated message category";
                  }

                  leaf group {
                    type string;
                    description
                      "Correlated message group";
                  }

                  leaf message-code {
                    type string;
                    description
                      "Correlated message code";
                  }
                }  // list non-root-cause
              }  // container non-root-causes

              container root-cause {
                description "The root cause";
                leaf category {
                  type string;
                  description
                    "Root message category";
                }

                leaf group {
                  type string;
                  description
                    "Root message group";
                }

                leaf message-code {
                  type string;
                  description
                    "Root message code";
                }
              }  // container root-cause

              leaf timeout {
                type uint32 {
                  range "1..7200000";
                }
                units "millisecond";
                description
                  "Timeout (time to wait for active correlation) in
milliseconds";
              }
            }  // container stateful

            container apply-to {
              description "Apply the Rules";
              container contexts {
                description
                  "Apply rule to a specified list of contexts,
e.g. interfaces";
                leaf-list context {
                  type string;
                  max-elements 32;
                  description
                    "One or more context names";
                }
              }  // container contexts

              container locations {
                description
                  "Apply rule to a specified list of Locations";
                leaf-list location {
                  type xr:Node-id;
                  max-elements 32;
                  description
                    "One or more Locations";
                }
              }  // container locations

              leaf all-of-router {
                type empty;
                description
                  "Apply the rule to all of the router";
              }
            }  // container apply-to

            leaf name {
              type string {
                length "1..32";
              }
              description "Rule name";
            }

            container applied-to {
              description
                "Applied to the Rule or Ruleset";
              container contexts {
                description
                  "Table of configured contexts to apply";
                list context {
                  key "context";
                  description "A context";
                  leaf context {
                    type string {
                      length "1..32";
                    }
                    description "Context";
                  }
                }  // list context
              }  // container contexts

              container locations {
                description
                  "Table of configured locations to apply";
                list location {
                  key "location";
                  description "A location";
                  leaf location {
                    type xr:Node-id;
                    description "Location";
                  }
                }  // list location
              }  // container locations

              leaf all {
                type empty;
                description
                  "Apply to all of the router";
              }
            }  // container applied-to
          }  // list rule
        }  // container rules

        container rule-sets {
          description
            "Table of configured rulesets";
          list rule-set {
            key "name";
            description "Ruleset name";
            container rulenames {
              description
                "Table of configured rulenames";
              list rulename {
                key "rulename";
                description "A rulename";
                leaf rulename {
                  type string {
                    length "1..32";
                  }
                  description "Rule name";
                }
              }  // list rulename
            }  // container rulenames

            leaf name {
              type string {
                length "1..32";
              }
              description "Ruleset name";
            }

            container applied-to {
              description
                "Applied to the Rule or Ruleset";
              container contexts {
                description
                  "Table of configured contexts to apply";
                list context {
                  key "context";
                  description "A context";
                  leaf context {
                    type string {
                      length "1..32";
                    }
                    description "Context";
                  }
                }  // list context
              }  // container contexts

              container locations {
                description
                  "Table of configured locations to apply";
                list location {
                  key "location";
                  description "A location";
                  leaf location {
                    type xr:Node-id;
                    description "Location";
                  }
                }  // list location
              }  // container locations

              leaf all {
                type empty;
                description
                  "Apply to all of the router";
              }
            }  // container applied-to
          }  // list rule-set
        }  // container rule-sets

        leaf buffer-size {
          type uint32 {
            range "1024..52428800";
          }
          description
            "Configure size of the correlator buffer";
        }
      }  // container correlator

      container suppression {
        description
          "Configure properties of the syslog/alarm
suppression";
        container rules {
          description
            "Table of configured rules";
          list rule {
            key "name";
            description "Rule name";
            container applied-to {
              description
                "Applied to the Rule";
              container sources {
                description
                  "Table of configured sources to apply";
                list source {
                  key "source";
                  description
                    "An alarm source";
                  leaf source {
                    type xr:Node-id;
                    description "Source";
                  }
                }  // list source
              }  // container sources

              leaf all {
                type empty;
                description
                  "Apply to all of the router";
              }
            }  // container applied-to

            container alarm-causes {
              description
                "Causes of alarms to be suppressed";
              list alarm-cause {
                key "category group code";
                description
                  "Category, Group and Code of alarm/syslog to
be suppressed";
                leaf category {
                  type string {
                    length "1..32";
                  }
                  description "Category";
                }

                leaf group {
                  type string {
                    length "1..32";
                  }
                  description "Group";
                }

                leaf code {
                  type string {
                    length "1..32";
                  }
                  description "Code";
                }
              }  // list alarm-cause
            }  // container alarm-causes

            leaf all-alarms {
              type empty;
              description
                "Suppress all alarms";
            }

            leaf name {
              type string {
                length "1..32";
              }
              description "Rule name";
            }
          }  // list rule
        }  // container rules
      }  // container suppression
    }  // container syslog
  }  // module Cisco-IOS-XR-infra-syslog-cfg