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 syslog
  }  // module Cisco-IOS-XR-infra-syslog-cfg