module dell-base-routing {

    yang-version 1;

    namespace
      "http://www.dellemc.com/networking/os10/dell-base-routing";

    prefix base-route;

    import ietf-yang-types {
      prefix yang;
    }
    import dell-base-common {
      prefix base-cmn;
    }
    import dell-base-interface-common {
      prefix base-if;
    }

    organization "Dell EMC";

    contact "http://www.dell.com/support";

    description
      "The NAS Routing service maintain the routing related configuration and operrational data
 in the form of route objects.
 This model contains a collection of YANG definitions for
 managing these routing objects

 Copyright (c) 2015-2019 by Dell EMC, All rights reserved.";

    revision "2018-12-05" {
      description
        "This revision adds an attribute in peer routing entry
                  to allow control of ingress only termination.";
      reference
        "Network Platform Abstraction";

    }

    revision "2019-03-21" {
      description
        "This revision adds the flags on nexthop entry for EVPN symmetric IRB
         and BGP unnumbered interface requirements.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-11-14" {
      description
        "This revision adds the flags on neighbor entry for no age out requirement.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-10-23" {
      description
        "This revision adds the support for resilient hashing enable/disable for routing globals.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-10-03" {
      description
        "Adding fib statistics in hardware to model.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-08-17" {
      description
        "Fixing pyang IETF errors and adding documentation to the model.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-08-10" {
      description
        "This revision adds the neighbor flush RPC.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-08-07" {
      description
        "This revision adds the VRF name in the neighbor entry.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-07-05" {
      description
        "This revision adds the VRF name in the IP unreachable configuration.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-04-05" {
      description
        "This revision adds the NH VRF name in the existing RPC to append or
        delete nexthop(s) to/from an existing leaked route from one VRF to another.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-04-02" {
      description
        "This revision adds the VRF name in the next-hop entry to support the route leaking from one VRF to another.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-03-12" {
      description
        "This revision adds the support for proxy ARP enable/disable on router interface.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-02-09" {
      description
        "This revision adds the config support for virtual routing
 configuration object to configure peer IP.";
      reference
        "Network Platform Abstraction";

    }

    revision "2018-01-23" {
      description
        "This revision adds the config support for ICMP redirects.";
      reference
        "Network Platform Abstraction";

    }

    revision "2017-01-11" {
      description
        "This revision adds the event filter to publish the selective routes,
by default, no route events will be published.";
      reference
        "Network Platform Abstraction";

    }

    revision "2016-04-05" {
      description
        "VLT Peer routing enable/disable support";
      reference
        "Network Platform Abstraction";

    }

    revision "2014-08-06" {
      description "Initial revision.";
      reference
        "Network Platform Abstraction";

    }


    identity routing-object-base {
      description
        "Base identity from which specific routing protocols are
derived.";
    }

    typedef rt-owner {
      type enumeration {
        enum "os-static" {
          value 1;
        }
        enum "os-privileged" {
          value 2;
        }
        enum "dc-rtm" {
          value 3;
        }
        enum "mgmtroute" {
          value 4;
        }
        enum "zebra" {
          value 5;
        }
        enum "bird" {
          value 6;
        }
        enum "thirdparty-apps" {
          value 7;
        }
      }
      description
        "Component that owns routing object";
    }

    typedef rt-type {
      type enumeration {
        enum "static" {
          value 1;
        }
        enum "dynamic" {
          value 2;
        }
      }
      description
        "Route object type based on whether it is configured or dynamically learnt";
    }

    typedef nh-type {
      type enumeration {
        enum "regular" {
          value 1;
        }
        enum "interface" {
          value 2;
        }
        enum "null0" {
          value 3;
        }
        enum "loopback" {
          value 4;
        }
        enum "ecmp" {
          value 5;
        }
        enum "wecmp" {
          value 6;
        }
        enum "protection-switching" {
          value 7;
        }
        enum "other" {
          value 8;
        }
      }
      description
        "Possible types of the next hop";
    }

    typedef nbr-flags {
      type enumeration {
        enum
          "age_out_1d_bridge_remote_mac_disable" {
          value 1;
        }
        enum "age_out_enable" {
          value 2;
        }
        enum "other" {
          value 3;
        }
      }
      description
        "Possible flags of the neighbor";
    }

    typedef nh-flags {
      type enumeration {
        enum "onlink" {
          value 1;
          description
            "Pretend that the nexthop is directly attached to this link,
                        even if it does not match any interface prefix.";
        }
      }
      description
        "Possible flags of the nexthop";
    }

    typedef hash-info {
      type enumeration {
        enum "mac-based" {
          value 1;
        }
        enum "ip" {
          value 2;
        }
        enum "mac-ip" {
          value 3;
        }
      }
      description "Types of hash info";
    }

    typedef rt-status {
      type enumeration {
        enum "up" {
          value 1;
        }
        enum "down" {
          value 2;
        }
      }
      description
        "Route object operational status";
    }

    typedef rt-mode {
      type enumeration {
        enum "default" {
          value 1;
        }
        enum "scaled-l3-hosts" {
          value 2;
        }
        enum "scaled-l3-routes" {
          value 3;
        }
      }
      description
        "Possible Unified Forwarding Table (UFT) modes";
    }

    typedef neighbor-state {
      type enumeration {
        enum "incomplete" {
          value 1;
        }
        enum "reachable" {
          value 2;
        }
        enum "stale" {
          value 4;
        }
        enum "delay" {
          value 8;
        }
        enum "probe" {
          value 16;
        }
      }
      description "Status of the neighbor";
    }

    typedef rt-operation-type {
      type enumeration {
        enum "append" {
          value 1;
          description
            "Operation to append nexthop(s) to an existing route";
        }
        enum "delete" {
          value 2;
          description
            "Operation to delete nexthop(s) from an existing route";
        }
      }
      description
        "Types of operations that can be operated on the routes";
    }

    typedef special-next-hop {
      type enumeration {
        enum "blackhole" {
          value 1;
          description
            "Silently discard the packet.";
        }
        enum "unreachable" {
          value 2;
          description
            "Discard the packet and notify the sender with an error
           message indicating that the destination host is unreachable.";
        }
        enum "prohibit" {
          value 3;
          description
            "Discard the packet and notify the sender with an error
           message indicating that the communication is
           administratively prohibited.";
        }
        enum "receive" {
          value 4;
          description
            "The packet will be received by the local system.";
        }
      }
      description
        "Different actions that a routing object can impose on a packet";
    }

    grouping next-hop {
      description
        "Set of attributes defining the next hop";
      leaf nh-id {
        type uint32;
        description "ID for next-hop";
      }

      leaf nh-addr {
        type base-cmn:ip-address;
        description "IP address";
      }

      leaf ifindex {
        type base-cmn:logical-ifindex;
        description
          "Logical IF index, in case the next hop is an interface or null0";
      }

      leaf ifname {
        type string;
        description
          "Name of the interface through which this next-hop is reachable";
      }

      leaf weight {
        type uint32;
        description "Used for Weighted ECMP";
      }

      leaf resolved {
        type boolean;
        description
          "Flag indicating whether the nexthop is resolved";
      }

      leaf npu-prg-done {
        type boolean;
        default 'false';
        description
          "Flag indicating whether the NPU programming is done for this entry";
      }

      leaf flags {
        type nh-flags;
        description "Nexthop flags";
      }
    }  // grouping next-hop

    grouping next-hop-entry {
      description
        "Grouping of the next hop entry";
      leaf nh-vrf-name {
        type string;
        description "VRF device name";
      }

      leaf nh-count {
        type uint32;
        description "Number of next hops";
      }

      leaf group-id {
        type uint32;
        description
          "ECMP group ID or Non-ECMP nexthop ID";
      }

      leaf nh-type {
        type nh-type;
        description "Type of next hop";
      }

      leaf hash-info {
        type hash-info;
        description "Hashing mechanisms";
      }

      list nh-list {
        key "nh-addr";
        description
          "Next-Hop info depending on the number of next-hops";
        uses next-hop;
      }  // list nh-list
    }  // grouping next-hop-entry

    grouping special-next-hop-entry {
      description
        "This grouping provides a leaf with an enumeration of special
          next-hops.";
      leaf special-next-hop {
        type special-next-hop;
        description
          "Special next-hop options.";
      }
    }  // grouping special-next-hop-entry

    grouping l3-route-entry {
      description
        "Set of attributes that defines the l3 route entry";
      leaf vrf-id {
        type uint32;
        status obsolete;
        description "VRF ID";
      }

      leaf route-prefix {
        type base-cmn:ip-address;
        description "route address";
      }

      leaf prefix-len {
        type uint32;
        description "Prefix Length";
      }

      leaf af {
        type base-cmn:af-type;
        description "Address Family";
      }

      uses next-hop-entry;

      leaf epoch-time {
        type uint64;
        description
          "epoch time of the route when it got updated";
      }

      leaf distance {
        type uint16;
        description
          "Protocol admin distance";
      }

      leaf protocol {
        type uint16;
        description "Protocol";
      }

      leaf ifindex {
        type base-cmn:logical-ifindex;
        description "Logical IF index";
      }

      leaf ifname {
        type string;
        description
          "Name of the interface on which this route is configured/learnt";
      }

      leaf owner {
        type rt-owner;
        description
          "Owner: OS Kernel Privileged, Static, DC-RTM, DC-RTM Static, Quagga etc";
      }

      leaf static-route {
        type boolean;
        description
          "Is route static or owned by other protocol";
      }

      leaf npu-prg-done {
        type boolean;
        default 'false';
        description
          "Is NPU programming done for this entry?";
      }

      uses special-next-hop-entry;
    }  // grouping l3-route-entry

    grouping l3-neighbor-entry {
      description
        "This grouping defines a neighbor-table entry";
      leaf address {
        type base-cmn:ip-address;
        description "IP address";
      }

      leaf mac-addr {
        type yang:mac-address;
        description "MAC address";
      }

      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf vrf-id {
        type uint32;
        status obsolete;
        description "VRF ID";
      }

      leaf af {
        type base-cmn:af-type;
        description "Address Family";
      }

      leaf ifindex {
        type base-cmn:logical-ifindex;
        description "Logical IF index";
      }

      leaf ifname {
        type string;
        description
          "Name of the interface through which this neighbor is reachable";
      }

      leaf owner {
        type rt-owner;
        description
          "Owner: OS Kernel DC-RTM, Management Route, Third party app etc";
      }

      leaf flags {
        type nbr-flags;
        description "Neighbor flags";
      }

      leaf state {
        type uint32;
        description
          "Dynamic neighbor entry states";
      }

      leaf type {
        type rt-type;
        description "Neighbor entry type";
      }

      leaf age-timeout {
        type uint32;
        units "seconds";
        description
          "Validity of the routing entry in seconds";
      }

      leaf npu-prg-done {
        type boolean;
        default 'false';
        description
          "Is NPU programming done for this entry?";
      }
    }  // grouping l3-neighbor-entry

    list obj {
      key "vrf-name";
      description
        "This grouping defines the routing domain object";
      leaf vrf-id {
        type uint32;
        status obsolete;
        description
          "vrf-name is used in place of vrf-id.";
      }

      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf switch-id {
        type uint32;
        description
          "Logical Switch to which this routing-domain belongs.";
      }

      leaf status {
        type rt-status;
        description
          "Status of the routing-object-instance";
      }

      list entry {
        key "af route-prefix prefix-len";
        description
          "An entry of a L3 route table";
        uses l3-route-entry;
      }  // list entry

      list nbr {
        key "af address";
        description
          "An entry of a neighbor (ARP/ND) table";
        uses l3-neighbor-entry;
      }  // list nbr

      leaf nsf-enabled {
        type boolean;
        description "Is NSF enabled?";
      }

      leaf eor {
        type boolean;
        description
          "Is End of RIB reached ?";
      }
    }  // list obj

    container routing-globals {
      description
        "Routing and Forwarding global configuration attributes";
      leaf resilient-hash-enable {
        type boolean;
        default 'false';
        description
          "Value to specify if resilient hash is enabled or disabled";
      }
    }  // container routing-globals

    grouping nexthop-tracking-object {
      description
        "Set of attributes present in the next-hop tracking object";
      leaf vrf-id {
        type uint32;
        status obsolete;
        description "VRF ID";
      }

      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf af {
        type base-cmn:af-type;
        description "Address Family";
      }

      leaf dest-addr {
        type base-cmn:ip-address;
        description
          "Route/Nexthop address to be tracked";
      }

      leaf data {
        type base-cmn:ip-nexthop-group-opaque-data;
        description
          "Opaque blob containing hardware specific data for
          the Next-Hop Group ID/Egress object ID as returned by NPU for single or multipath Nexthop";
      }

      leaf nh-count {
        type uint32;
        description
          "Number of next hops in resolved status";
      }

      list nh-info {
        key "af address";
        description
          "An entry of a neighbor (ARP/ND) table that's in resolved status";
        uses l3-neighbor-entry;
      }  // list nh-info
    }  // grouping nexthop-tracking-object

    list nh-track {
      key "vrf-id af dest-addr";
      description
        "Route/Nexthop Tracking Service";
      uses nexthop-tracking-object;
    }  // list nh-track

    grouping hardware-forwarding-configuration-table {
      description
        "Forwarding Configuration Table";
      leaf vrf-id {
        type uint32;
        status obsolete;
        description "VRF ID";
      }

      leaf hash-algo-seed-val {
        type uint32;
        description
          "hash-algorithm seed value ";
      }

      leaf enable-v4 {
        type boolean;
        default 'true';
        description
          "Is route ipv4 routing enabled?";
      }

      leaf enable-v6 {
        type boolean;
        default 'false';
        description
          "Is route ipv6 routing enabled?";
      }

      leaf deterministic-ECMP-v4-enabled {
        type boolean;
        default 'false';
        description
          "Is Deterministic-ECMP enabled for ipv4?";
      }

      leaf deterministic-ECMP-v6-enabled {
        type boolean;
        default 'false';
        description
          "Is Deterministic-ECMP enabled for ipv6?";
      }

      leaf mode {
        type rt-mode;
        description
          "hardware-forwarding-table mode";
      }

      leaf nsf-v4-enabled {
        type boolean;
        default 'false';
        description
          "Flag indicating whether ipv4 NSF is enabled";
      }

      leaf nsf-v6-enabled {
        type boolean;
        default 'false';
        description
          "Flag indicating whether ipv6 NSF is enabled";
      }

      leaf ecmp-group-max-paths {
        type uint32;
        description
          "ecmp-group maximum-paths";
      }

      leaf ecmp-group-number {
        type uint32;
        description "ecmp-group number";
      }

      leaf ecmp-group-path-fallback {
        type boolean;
        default 'false';
        description
          "Flag indicating whether ecmp-group path-fallback is active";
      }

      leaf start-rtm-download {
        type boolean;
        default 'false';
        description
          "Flag indicating to start the route download from RTM";
      }

      leaf stop-rtm-download {
        type boolean;
        default 'false';
        description
          "Flag indicating to stop the route download from RTM";
      }
    }  // grouping hardware-forwarding-configuration-table

    container fwd-tbl-confg {
      description
        "Routing and Forwarding configuration table";
      uses hardware-forwarding-configuration-table;
    }  // container fwd-tbl-confg

    rpc flush {
      description "Clear FIB entries";
      input {
        leaf vrf-id {
          type uint32;
          default '0';
          status obsolete;
          description "VRF ID";
        }

        leaf vrf-name {
          type string;
          description "VRF device name";
        }

        leaf af {
          type base-cmn:af-type;
          mandatory true;
          description
            "Address Family of the FIB entries to be cleared";
        }
      }
    }  // rpc flush

    grouping fib-configuration-table {
      description "FIB configuration table";
      leaf vrf-id {
        type uint32;
        status obsolete;
        description "VRF ID";
      }

      leaf af {
        type base-cmn:af-type;
        description "Address Family";
      }

      leaf summary {
        type boolean;
        default 'false';
        description
          "Show summary command returns the number of FIB route count";
      }

      leaf route-count {
        type uint32;
        description "FIB Route count";
      }
    }  // grouping fib-configuration-table

    container fib {
      description "FIB configuration";
      uses fib-configuration-table;
    }  // container fib

    container peer-routing-config {
      description
        "This defines the peer routing enable/disable object";
      leaf vrf-id {
        type uint32;
        default '0';
        status obsolete;
        description "VRF ID";
      }

      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf ifname {
        type string;
        description
          "Physical/Logical L3 interface";
      }

      leaf peer-mac-addr {
        type yang:mac-address;
        description "Peer MAC address";
      }

      leaf ingress-only {
        type boolean;
        description
          "Optional attribute to configure the ingress only termination
                 for the peer routing entry on an interface. If the peer routing
                 entry to be applied for both ingress termination and egress
                 routing MAC, then this attribute should be set to false. This
                 attribute can only be configured during create when ifname is valid.";
      }
    }  // container peer-routing-config

    container virtual-routing-config {
      description
        "This defines the virtual routing configuration object";
      list virtual-routing-ip-config {
        key "vrf-name af ifname ip";
        description
          "List of virtual routing IP configuration objects.
                   These are applied on the routing info associated with the peer details.";
        leaf vrf-name {
          type string;
          description "VRF device name";
        }

        leaf af {
          type base-cmn:af-type;
          description
            "Address Family of the peer's IP address to be configured.";
        }

        leaf ifname {
          type string;
          description
            "Physical/Logical L3 interface";
        }

        leaf ip {
          type base-cmn:ip-address;
          description
            "Peer IP address to be configured.";
        }
      }  // list virtual-routing-ip-config
    }  // container virtual-routing-config

    list fib-stats {
      key "vrf-name af";
      description
        "This defines FIB statistics per address family or per VRF instance or per L3 logical/physical interface name.";
      leaf vrf-name {
        type string;
        description "VRF instance name";
      }

      leaf af {
        type base-cmn:af-type;
        description "Address Family.";
      }

      leaf current-route-entries {
        type uint32;
        config false;
        description
          "Number of current route entries in NPU";
      }

      leaf current-neighbour-entries {
        type uint32;
        config false;
        description
          "Number of current neighbour entries in NPU";
      }
    }  // list fib-stats

    rpc route-nh-operation {
      description
        "RPC to append or delete nexthop(s) to/from an existing route.";
      input {
        leaf operation {
          type rt-operation-type;
          mandatory true;
          description
            "Operation to perform for the given nexthop(s) of an existing route.
                     This is valid only during update to an existing route.";
        }

        leaf vrf-id {
          type uint32;
          default '0';
          status obsolete;
          description "VRF ID";
        }

        leaf vrf-name {
          type string;
          description "VRF device name";
        }

        leaf af {
          type base-cmn:af-type;
          mandatory true;
          description "Address Family";
        }

        leaf route-prefix {
          type base-cmn:ip-address;
          mandatory true;
          description "Route address";
        }

        leaf prefix-len {
          type uint32;
          mandatory true;
          description "Route prefix Length";
        }

        leaf nh-count {
          type uint32;
          mandatory true;
          description
            "Number of next hops added/deleted";
        }

        leaf nh-vrf-name {
          type string;
          description
            "VRF device name for next hop";
        }

        list nh-list {
          key "nh-addr";
          description
            "Next-Hop info depending on the number of next-hops added/deleted";
          uses next-hop;
        }  // list nh-list
      }
    }  // rpc route-nh-operation

    list ip-unreachables-config {
      key "vrf-name af ifname";
      description
        "Provide list of network interfaces that can initiate ICMP unreachable messages for non-routable traffic.";
      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf af {
        type base-cmn:af-type;
        description "Address Family";
      }

      leaf ifname {
        type string;
        description "Network interface";
      }
    }  // list ip-unreachables-config

    rpc interface-mode-change {
      description
        "This method is used to notify routing component for change
      of the interface mode from None to L2 or vice versa.
      On receiving this notification, routing component will perform the following:
      when mode changes from None to L2, routing configurations on this interface
       will be removed from hardware.
      when mode changes from L2 to None, cached routing configurations (if any)
       on this interface will be applied to hardware.";
      input {
        leaf ifname {
          type string;
          mandatory true;
          description
            "Interface name for which the mode change is triggered";
        }

        leaf mode {
          type base-if:mode;
          mandatory true;
          description
            "Interface mode in notification.
        Modes that are of interest to routing component is None/L2.";
        }
      }
    }  // rpc interface-mode-change

    list event-filter {
      key "vrf-name type";
      description
        "Provide list of filters to publish the selective route events,
                 by default, no route events will be published.";
      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf type {
        type rt-owner;
        description
          "This type is used to publish the selective route type events,
                     the event filter is now supported only for management routes.";
      }

      leaf enable {
        type boolean;
        description
          "If this is set to true, the filter will be applied for a selective
          route type in the VRF and false otherwise.";
      }
    }  // list event-filter

    list ip-redirects-config {
      key "vrf-name ifname";
      description
        "Provide list of network interfaces that can initiate ICMP redirect messages for routable traffic, when it ingress and egress on same router interface.";
      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf ifname {
        type string;
        description "Network interface";
      }
    }  // list ip-redirects-config

    list proxy-arp-config {
      key "vrf-name ifname";
      description
        "Provide list of network interfaces that can reply to ARP request
                   on behalf of the neighbor for the target IP matching the local subnet.";
      leaf vrf-name {
        type string;
        description "VRF device name";
      }

      leaf ifname {
        type string;
        description "Network interface";
      }
    }  // list proxy-arp-config

    rpc nbr-flush {
      description
        "Flush the Neighbor entries for given input, all neighbors or particular interface in a VRF.";
      input {
        leaf vrf-name {
          type string;
          mandatory true;
          description "VRF device name";
        }

        leaf af {
          type base-cmn:af-type;
          default "inet";
          description
            "Address Family of the Neighbor entries to be cleared";
        }

        leaf-list ifname {
          type string;
          description
            "Flush the Neighbor entries configured/learnt on list of interfaces.";
        }
      }
    }  // rpc nbr-flush
  }  // module dell-base-routing