module Cisco-IOS-XR-ip-rip-cfg {

    yang-version 1;

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

    prefix ip-rip-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 ip-rip package configuration.
     
     This module contains definitions
     for the following management objects:
       rip: RIP configuration
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.0.0";

    typedef Rip-ext-community {
      type enumeration {
        enum "as" {
          value 0;
          description "AS:nn format";
        }
        enum "ipv4-address" {
          value 1;
          description
            "IPV4Address:nn format";
        }
        enum "four-byte-as" {
          value 2;
          description "4-byte ASN format";
        }
      }
      description "Rip ext community";
    }

    typedef Default-redist-route {
      type enumeration {
        enum "all" {
          value 0;
          description "All routes";
        }
      }
      description "Default redist route";
    }

    typedef Default-information-option {
      type enumeration {
        enum "always" {
          value 0;
          description "Always";
        }
        enum "policy" {
          value 1;
          description "Use route-policy";
        }
      }
      description
        "Default information option";
    }

    typedef Isis-redist-route {
      type enumeration {
        enum "level1" {
          value 1;
          description "Level-1 routes only";
        }
        enum "level2" {
          value 2;
          description "Level-1 routes only";
        }
        enum "level1-and2" {
          value 3;
          description
            "Level-1 and level-2 routes";
        }
      }
      description "Isis redist route";
    }

    typedef Bgp-redist-route {
      type enumeration {
        enum "all" {
          value 0;
          description "All routes";
        }
        enum "internal" {
          value 512;
          description "Internal routes only";
        }
        enum "external" {
          value 1024;
          description "External routes only";
        }
        enum "local" {
          value 2048;
          description "Local routes only";
        }
      }
      description "Bgp redist route";
    }

    typedef Rip-auth-mode {
      type enumeration {
        enum "text" {
          value 2;
          description "Text mode";
        }
        enum "md5" {
          value 3;
          description "MD5 mode";
        }
      }
      description "Rip auth mode";
    }

    container rip {
      description "RIP configuration";
      container default-vrf {
        description
          "RIP configuration for Default VRF";
        leaf enable {
          type empty;
          description
            "Starts RIP configuration for Default VRF";
        }

        leaf broadcast-for-v2 {
          type empty;
          description
            "Send RIP v2 output packets to broadcast address";
        }

        leaf distance {
          type uint32 {
            range "0..255";
          }
          default "120";
          description
            "Administrative distance";
        }

        container default-information {
          presence
            "Indicates a default-information node is configured.";
          description
            "Controls default information origination";
          leaf route-policy-name {
            type string;
            description "Route policy name";
          }

          leaf option {
            type Default-information-option;
            mandatory true;
            description "Origination option";
          }
        }  // container default-information

        leaf default-metric {
          type uint32 {
            range "0..16";
          }
          description
            "Default metric of redistributed routes";
        }

        leaf output-delay {
          type uint32 {
            range "8..50";
          }
          units "millisecond";
          description
            "Inter-packet delay for RIP updates";
        }

        leaf auto-summary {
          type empty;
          description
            "Enable automatic network number summarization";
        }

        container redistribution {
          description
            "Redistribute information from another routing
protocol";
          container connected {
            presence "enable connected";
            description
              "Redistribute connected routes";
            leaf route-policy-name {
              type string;
              description
                "Route Policy name";
            }

            leaf route-type {
              type Default-redist-route;
              description "Route type";
            }
          }  // container connected

          container bgps {
            description
              "Redistribute BGP routes";
            list bgp {
              key "asnxx asnyy";
              description
                "Autonomous system number";
              leaf asnxx {
                type uint32 {
                  range "0..65535";
                }
                description
                  "Higher 16 bits of 4-byte BGP AS number";
              }

              leaf asnyy {
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "2-byte or 4-byte BGP AS number";
              }

              leaf policy {
                type string;
                description
                  "Route Policy name";
              }

              leaf type {
                type Bgp-redist-route;
                description "Route type";
              }
            }  // list bgp
          }  // container bgps

          container isises {
            description
              "Redistribute IS-IS routes";
            list isis {
              key "isis-name";
              description
                "Redistribute IS-IS routes";
              leaf isis-name {
                type xr:Cisco-ios-xr-string;
                description
                  "IS-IS instance name";
              }

              leaf route-policy-name {
                type string;
                description
                  "Route Policy name";
              }

              leaf route-type {
                type Isis-redist-route;
                description "Route type";
              }
            }  // list isis
          }  // container isises

          container eigrp-s {
            description
              "Redistribute EIGRP routes";
            list eigrp {
              key "as";
              description
                "Redistribute EIGRP routes";
              leaf as {
                type uint32 {
                  range "1..65535";
                }
                description
                  "Autonomous system number";
              }

              leaf route-policy-name {
                type string;
                description
                  "Route Policy name";
              }

              leaf route-type {
                type Default-redist-route;
                description "Route type";
              }
            }  // list eigrp
          }  // container eigrp-s

          container static {
            presence "enable static";
            description
              "Redistribute static routes";
            leaf route-policy-name {
              type string;
              description
                "Route Policy name";
            }

            leaf route-type {
              type Default-redist-route;
              description "Route type";
            }
          }  // container static

          container ospfs {
            description
              "Redistribute OSPF routes";
            list ospf {
              key "ospf-name";
              description
                "Redistribute OSPF routes";
              leaf ospf-name {
                type xr:Cisco-ios-xr-string;
                description
                  "Process ID for the OSPF instance";
              }

              leaf route-policy-name {
                type string;
                description
                  "Route Policy name";
              }

              leaf internal {
                type boolean;
                description
                  "Internal routes";
              }

              leaf external {
                type boolean;
                description
                  "External routes";
              }

              leaf external-type {
                type uint32 {
                  range "0..2";
                }
                description
                  "External route type";
              }

              leaf nssa-external {
                type boolean;
                description
                  "NSSA External routes";
              }

              leaf nssa-external-type {
                type uint32 {
                  range "0..2";
                }
                description
                  "NSSA External route type";
              }
            }  // list ospf
          }  // container ospfs
        }  // container redistribution

        container ip-distances {
          description
            "Table of IP specific administrative distances";
          list ip-distance {
            key "address netmask";
            description
              "IP specific administrative distance";
            leaf address {
              type inet:ipv4-address-no-zone;
              description
                "IP Source address";
            }

            leaf netmask {
              type inet:ipv4-address-no-zone;
              description "IP address mask";
            }

            leaf distance {
              type uint32 {
                range "0..255";
              }
              mandatory true;
              description
                "Administrative distance";
            }
          }  // list ip-distance
        }  // container ip-distances

        leaf policy-out {
          type string;
          description
            "Route Policy for outbound routing updates";
        }

        container interfaces {
          description
            "Table of RIP interfaces";
          list interface {
            key "interface-name";
            description "RIP interface name";
            container authentication {
              presence
                "Indicates a authentication node is configured.";
              description
                "Authentication keychain and mode";
              leaf keychain {
                type string;
                mandatory true;
                description
                  "Name of keychain";
              }

              leaf mode {
                type Rip-auth-mode;
                mandatory true;
                description
                  "Authentication mode";
              }
            }  // container authentication

            container site-of-origin {
              description
                "SOO community for prefixes learned over this
interface";
              leaf type {
                type Rip-ext-community;
                description
                  "Extended community type";
              }

              leaf as-xx {
                when
                  "../type != 'as' and ../type != 'ipv4-address'" {
                  description
                    "../Type != AS and ../Type != IPV4Address";
                }
                type uint32 {
                  range "0..65535";
                }
                description
                  "AS Number for AS:nn format";
              }

              leaf as-yy {
                when
                  "../type != 'ipv4-address'" {
                  description
                    "../Type != IPV4Address";
                }
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "32 bit value for AS:nn format";
              }

              leaf as-index {
                when
                  "../type != 'ipv4-address'" {
                  description
                    "../Type != IPV4Address";
                }
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "AS Number Index";
              }

              leaf address {
                when
                  "../type = 'ipv4-address'" {
                  description
                    "../Type = IPV4Address";
                }
                type inet:ipv4-address-no-zone;
                description
                  "IPV4 address for IPV4Address:nn format";
              }

              leaf address-index {
                when
                  "../type = 'ipv4-address'" {
                  description
                    "../Type = IPV4Address";
                }
                type uint32 {
                  range "0..65535";
                }
                description
                  "16bit value for IPV4Address:nn format";
              }
            }  // container site-of-origin

            container receive-version {
              description
                "RIP versions supported for receiving
advertisements";
              leaf version1 {
                type boolean;
                description
                  "Support RIP version 1";
              }

              leaf version2 {
                type boolean;
                default "true";
                description
                  "Support RIP version 2";
              }
            }  // container receive-version

            container send-version {
              description
                "RIP versions supported for sending
advertisements";
              leaf version1 {
                type boolean;
                description
                  "Support RIP version 1";
              }

              leaf version2 {
                type boolean;
                default "true";
                description
                  "Support RIP version 2";
              }
            }  // container send-version

            leaf broadcast-for-v2 {
              type empty;
              description
                "Send RIP v2 output packets to broadcast
address";
            }

            leaf poison-reverse {
              type empty;
              description
                "Enable poison reverse";
            }

            leaf passive {
              type empty;
              description
                "Suppress routing updates on this interface";
            }

            leaf enable {
              type empty;
              description
                "Starts RIP interface configuration";
            }

            leaf policy-out {
              type string;
              description
                "Route Policy for outbound routing updates";
            }

            leaf accept-metric-zero {
              type empty;
              description
                "Accept RIP updates with metric 0";
            }

            leaf policy-in {
              type string;
              description
                "Route Policy for inbound routing updates";
            }

            leaf split-horizon-disable {
              type empty;
              description
                "Disable split horizon";
            }

            leaf interface-name {
              type xr:Interface-name;
              description "Interface name";
            }
          }  // list interface
        }  // container interfaces

        container neighbors {
          description
            "Configure RIP Neighbors";
          list neighbor {
            key "neighbor-address";
            description "Neighbor address";
            leaf neighbor-address {
              type inet:ipv4-address-no-zone;
              description "IPv4 address";
            }
          }  // list neighbor
        }  // container neighbors

        leaf validate-source-disable {
          type empty;
          description
            "Disable validation of source address of routing
updates";
        }

        leaf maximum-paths {
          type uint32 {
            range "1..128";
          }
          default "4";
          description
            "Maximum number of paths allowed per route";
        }

        leaf nsf {
          type empty;
          description
            "Enable Cisco Non Stop Forwarding";
        }

        leaf policy-in {
          type string;
          description
            "Route Policy for inbbound routing updates";
        }

        container timers {
          presence
            "Indicates a timers node is configured.";
          description
            "Various routing timers";
          leaf update-timer {
            type uint32 {
              range "5..50000";
            }
            mandatory true;
            description
              "Interval between updates";
          }

          leaf invalid-timer {
            type uint32 {
              range "15..200000";
            }
            mandatory true;
            description "Invalid";
          }

          leaf holddown-timer {
            type uint32 {
              range "15..200000";
            }
            mandatory true;
            description "Holddown";
          }

          leaf flush-timer {
            type uint32 {
              range "16..250000";
            }
            mandatory true;
            description "Flush";
          }
        }  // container timers
      }  // container default-vrf

      container vrfs {
        description
          "VRF related RIP configuration";
        list vrf {
          key "vrf-name";
          description
            "RIP configuration for a particular VRF";
          leaf enable {
            type empty;
            description
              "Starts RIP configuration for a particular VRF";
          }

          leaf vrf-name {
            type xr:Cisco-ios-xr-string;
            description "VRF Name";
          }

          leaf broadcast-for-v2 {
            type empty;
            description
              "Send RIP v2 output packets to broadcast address";
          }

          leaf distance {
            type uint32 {
              range "0..255";
            }
            default "120";
            description
              "Administrative distance";
          }

          container default-information {
            presence
              "Indicates a default-information node is configured.";
            description
              "Controls default information origination";
            leaf route-policy-name {
              type string;
              description
                "Route policy name";
            }

            leaf option {
              type Default-information-option;
              mandatory true;
              description
                "Origination option";
            }
          }  // container default-information

          leaf default-metric {
            type uint32 {
              range "0..16";
            }
            description
              "Default metric of redistributed routes";
          }

          leaf output-delay {
            type uint32 {
              range "8..50";
            }
            units "millisecond";
            description
              "Inter-packet delay for RIP updates";
          }

          leaf auto-summary {
            type empty;
            description
              "Enable automatic network number summarization";
          }

          container redistribution {
            description
              "Redistribute information from another routing
protocol";
            container connected {
              presence "enable connected";
              description
                "Redistribute connected routes";
              leaf route-policy-name {
                type string;
                description
                  "Route Policy name";
              }

              leaf route-type {
                type Default-redist-route;
                description "Route type";
              }
            }  // container connected

            container bgps {
              description
                "Redistribute BGP routes";
              list bgp {
                key "asnxx asnyy";
                description
                  "Autonomous system number";
                leaf asnxx {
                  type uint32 {
                    range "0..65535";
                  }
                  description
                    "Higher 16 bits of 4-byte BGP AS number";
                }

                leaf asnyy {
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "2-byte or 4-byte BGP AS number";
                }

                leaf policy {
                  type string;
                  description
                    "Route Policy name";
                }

                leaf type {
                  type Bgp-redist-route;
                  description "Route type";
                }
              }  // list bgp
            }  // container bgps

            container isises {
              description
                "Redistribute IS-IS routes";
              list isis {
                key "isis-name";
                description
                  "Redistribute IS-IS routes";
                leaf isis-name {
                  type xr:Cisco-ios-xr-string;
                  description
                    "IS-IS instance name";
                }

                leaf route-policy-name {
                  type string;
                  description
                    "Route Policy name";
                }

                leaf route-type {
                  type Isis-redist-route;
                  description "Route type";
                }
              }  // list isis
            }  // container isises

            container eigrp-s {
              description
                "Redistribute EIGRP routes";
              list eigrp {
                key "as";
                description
                  "Redistribute EIGRP routes";
                leaf as {
                  type uint32 {
                    range "1..65535";
                  }
                  description
                    "Autonomous system number";
                }

                leaf route-policy-name {
                  type string;
                  description
                    "Route Policy name";
                }

                leaf route-type {
                  type Default-redist-route;
                  description "Route type";
                }
              }  // list eigrp
            }  // container eigrp-s

            container static {
              presence "enable static";
              description
                "Redistribute static routes";
              leaf route-policy-name {
                type string;
                description
                  "Route Policy name";
              }

              leaf route-type {
                type Default-redist-route;
                description "Route type";
              }
            }  // container static

            container ospfs {
              description
                "Redistribute OSPF routes";
              list ospf {
                key "ospf-name";
                description
                  "Redistribute OSPF routes";
                leaf ospf-name {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Process ID for the OSPF instance";
                }

                leaf route-policy-name {
                  type string;
                  description
                    "Route Policy name";
                }

                leaf internal {
                  type boolean;
                  description
                    "Internal routes";
                }

                leaf external {
                  type boolean;
                  description
                    "External routes";
                }

                leaf external-type {
                  type uint32 {
                    range "0..2";
                  }
                  description
                    "External route type";
                }

                leaf nssa-external {
                  type boolean;
                  description
                    "NSSA External routes";
                }

                leaf nssa-external-type {
                  type uint32 {
                    range "0..2";
                  }
                  description
                    "NSSA External route type";
                }
              }  // list ospf
            }  // container ospfs
          }  // container redistribution

          container ip-distances {
            description
              "Table of IP specific administrative distances";
            list ip-distance {
              key "address netmask";
              description
                "IP specific administrative distance";
              leaf address {
                type inet:ipv4-address-no-zone;
                description
                  "IP Source address";
              }

              leaf netmask {
                type inet:ipv4-address-no-zone;
                description
                  "IP address mask";
              }

              leaf distance {
                type uint32 {
                  range "0..255";
                }
                mandatory true;
                description
                  "Administrative distance";
              }
            }  // list ip-distance
          }  // container ip-distances

          leaf policy-out {
            type string;
            description
              "Route Policy for outbound routing updates";
          }

          container interfaces {
            description
              "Table of RIP interfaces";
            list interface {
              key "interface-name";
              description
                "RIP interface name";
              container authentication {
                presence
                  "Indicates a authentication node is configured.";
                description
                  "Authentication keychain and mode";
                leaf keychain {
                  type string;
                  mandatory true;
                  description
                    "Name of keychain";
                }

                leaf mode {
                  type Rip-auth-mode;
                  mandatory true;
                  description
                    "Authentication mode";
                }
              }  // container authentication

              container site-of-origin {
                description
                  "SOO community for prefixes learned over this
interface";
                leaf type {
                  type Rip-ext-community;
                  description
                    "Extended community type";
                }

                leaf as-xx {
                  when
                    "../type != 'as' and ../type != 'ipv4-address'" {
                    description
                      "../Type != AS and ../Type != IPV4Address";
                  }
                  type uint32 {
                    range "0..65535";
                  }
                  description
                    "AS Number for AS:nn format";
                }

                leaf as-yy {
                  when
                    "../type != 'ipv4-address'" {
                    description
                      "../Type != IPV4Address";
                  }
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "32 bit value for AS:nn format";
                }

                leaf as-index {
                  when
                    "../type != 'ipv4-address'" {
                    description
                      "../Type != IPV4Address";
                  }
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "AS Number Index";
                }

                leaf address {
                  when
                    "../type = 'ipv4-address'" {
                    description
                      "../Type = IPV4Address";
                  }
                  type inet:ipv4-address-no-zone;
                  description
                    "IPV4 address for IPV4Address:nn format";
                }

                leaf address-index {
                  when
                    "../type = 'ipv4-address'" {
                    description
                      "../Type = IPV4Address";
                  }
                  type uint32 {
                    range "0..65535";
                  }
                  description
                    "16bit value for IPV4Address:nn format";
                }
              }  // container site-of-origin

              container receive-version {
                description
                  "RIP versions supported for receiving
advertisements";
                leaf version1 {
                  type boolean;
                  description
                    "Support RIP version 1";
                }

                leaf version2 {
                  type boolean;
                  default "true";
                  description
                    "Support RIP version 2";
                }
              }  // container receive-version

              container send-version {
                description
                  "RIP versions supported for sending
advertisements";
                leaf version1 {
                  type boolean;
                  description
                    "Support RIP version 1";
                }

                leaf version2 {
                  type boolean;
                  default "true";
                  description
                    "Support RIP version 2";
                }
              }  // container send-version

              leaf broadcast-for-v2 {
                type empty;
                description
                  "Send RIP v2 output packets to broadcast
address";
              }

              leaf poison-reverse {
                type empty;
                description
                  "Enable poison reverse";
              }

              leaf passive {
                type empty;
                description
                  "Suppress routing updates on this interface";
              }

              leaf enable {
                type empty;
                description
                  "Starts RIP interface configuration";
              }

              leaf policy-out {
                type string;
                description
                  "Route Policy for outbound routing updates";
              }

              leaf accept-metric-zero {
                type empty;
                description
                  "Accept RIP updates with metric 0";
              }

              leaf policy-in {
                type string;
                description
                  "Route Policy for inbound routing updates";
              }

              leaf split-horizon-disable {
                type empty;
                description
                  "Disable split horizon";
              }

              leaf interface-name {
                type xr:Interface-name;
                description "Interface name";
              }
            }  // list interface
          }  // container interfaces

          container neighbors {
            description
              "Configure RIP Neighbors";
            list neighbor {
              key "neighbor-address";
              description "Neighbor address";
              leaf neighbor-address {
                type inet:ipv4-address-no-zone;
                description "IPv4 address";
              }
            }  // list neighbor
          }  // container neighbors

          leaf validate-source-disable {
            type empty;
            description
              "Disable validation of source address of routing
updates";
          }

          leaf maximum-paths {
            type uint32 {
              range "1..128";
            }
            default "4";
            description
              "Maximum number of paths allowed per route";
          }

          leaf nsf {
            type empty;
            description
              "Enable Cisco Non Stop Forwarding";
          }

          leaf policy-in {
            type string;
            description
              "Route Policy for inbbound routing updates";
          }

          container timers {
            presence
              "Indicates a timers node is configured.";
            description
              "Various routing timers";
            leaf update-timer {
              type uint32 {
                range "5..50000";
              }
              mandatory true;
              description
                "Interval between updates";
            }

            leaf invalid-timer {
              type uint32 {
                range "15..200000";
              }
              mandatory true;
              description "Invalid";
            }

            leaf holddown-timer {
              type uint32 {
                range "15..200000";
              }
              mandatory true;
              description "Holddown";
            }

            leaf flush-timer {
              type uint32 {
                range "16..250000";
              }
              mandatory true;
              description "Flush";
            }
          }  // container timers
        }  // list vrf
      }  // container vrfs
    }  // container rip
  }  // module Cisco-IOS-XR-ip-rip-cfg