module frr-zebra {
  yang-version 1.1;
  namespace "http://frrouting.org/yang/zebra";
  prefix frr-zebra;

  import ietf-yang-types {
    prefix yang;
  }

  import ietf-inet-types {
    prefix inet;
  }

  import frr-affinity-map {
    prefix frr-affinity-map;
  }

  import frr-route-map {
    prefix frr-route-map;
  }

  import frr-route-types {
    prefix frr-route-types;
  }

  import ietf-routing-types {
    prefix rt-types;
  }

  import frr-nexthop {
    prefix frr-nh;
  }

  import frr-routing {
    prefix frr-rt;
  }

  import frr-interface {
    prefix frr-interface;
  }

  import frr-vrf {
    prefix frr-vrf;
  }

  organization
    "FRRouting";
  contact
    "FRR Users List: <mailto:frog@lists.frrouting.org>
     FRR Development List: <mailto:dev@lists.frrouting.org>";
  description
    "This module defines a model for managing the FRR zebra daemon.

     Copyright 2020 FRRouting

     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions
     are met:

     1. Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.

     2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.

     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.";

  revision 2019-06-01 {
    description
      "Initial revision.";
  }

  typedef unix-timestamp {
    type uint32;
    units "seconds";
    description
      "An absolute time in seconds since the unix epoch.";
  }

  identity zebra-interface-type {
    description
      "zebra interface type.";
  }

  identity zif-other {
    base zebra-interface-type;
    description
      "Zebra interface type other.";
  }

  identity zif-bridge {
    base zebra-interface-type;
    description
      "Zebra interface type bridge.";
  }

  identity zif-vlan {
    base zebra-interface-type;
    description
      "Zebra interface type vlan.";
  }

  identity zif-vxlan {
    base zebra-interface-type;
    description
      "Zebra interface type vxlan.";
  }

  identity zif-vrf {
    base zebra-interface-type;
    description
      "Zebra interface type vrf.";
  }

  identity zif-veth {
    base zebra-interface-type;
    description
      "Zebra interface type veth.";
  }

  identity zif-bond {
    base zebra-interface-type;
    description
      "Zebra interface type bond.";
  }

  identity zif-bond-slave {
    base zebra-interface-type;
    description
      "Zebra interface type bond slave.";
  }

  identity zif-macvlan {
    base zebra-interface-type;
    description
      "Zebra interface type macvlan.";
  }

  /*
   * Multicast RPF mode configurable type
   */

  typedef mcast-rpf-lookup-mode {
    type enumeration {
      enum "none" {
        value 0;
        description
          "No mode set.";
      }
      enum "mrib-only" {
        value 1;
        description
          "Lookup in unicast RIB only.";
      }
      enum "urib-only" {
        value 2;
        description
          "Lookup in multicast RIB only.";
      }
      enum "mrib-then-urib" {
        value 3;
        description
          "Try multicast RIB first, fall back to unicast RIB.";
      }
      enum "lower-distance" {
        value 4;
        description
          "Lookup both unicast and mcast, use entry with lower distance.";
      }
      enum "longer-prefix" {
        value 5;
        description
          "Lookup both unicast and mcast, use entry with longer prefix.";
      }
    }
    description
      "Multicast RPF lookup behavior";
  }

  // End of ip6-route
  /*
   * VxLAN Network Identifier type
   */

  typedef vni-id-type {
    type uint32 {
      range "0..16777215";
    }
    description
      "A VxLAN network identifier value.";
  }

  typedef vni-vtep-flood-type {
    type enumeration {
      enum "head-end-repl" {
        value 0;
        description
          "Head-end replication.";
      }
      enum "disabled" {
        value 1;
        description
          "Flooding disabled.";
      }
      enum "pim-sm" {
        value 2;
        description
          "Multicast PIM-SM.";
      }
    }
  }

  /*
   * Common route data, shared by v4 and v6 routes.
   */

  grouping route-common {
    description
      "Common information about a route.";

    leaf distance {
      type uint8;
      description
        "Admin distance based on routing protocol.";
    }

    leaf metric {
      type uint32;
      description
        "Route metric value.";
    }

    leaf tag {
      type uint32 {
        range "1..4294967295";
      }
      description
        "Route tag value.";
    }

    leaf selected {
      type empty;
      description
        "Route is the selected or preferred route for the prefix.";
    }

    leaf installed {
      type empty;
      description
        "Route is installed in the FIB.";
    }

    leaf failed {
      type empty;
      description
        "Route installation in FIB has failed.";
    }

    leaf queued {
      type empty;
      description
        "Route has a pending FIB operation that has not completed.";
    }

    leaf internal-flags {
      type int32;
      description
        "Internal flags for the route.";
    }

    leaf internal-status {
      type int32;
      description
        "Internal status for the route.";
    }

    leaf uptime {
      type yang:date-and-time;
      description
        "Uptime for the route.";
    }

    uses frr-nh:frr-nexthop-group-operational;
  }

  // End of route-common
  /*
   * IPv4 Route object.
   */

  grouping ip4-route {
    description
      "An IPv4 route.";
    leaf prefix {
      type inet:ipv4-prefix;
      description
        "IP address (in the form A.B.C.D) and prefix length,
         separated by the slash (/) character. The range of
         values for the prefix-length is 0 to 32.";
    }

    leaf protocol {
      type frr-route-types:frr-route-types-v4;
      description
        "The protocol owning the route.";
    }

    uses route-common;
  }

  // End of ip4-route
  /*
   * IPv6 Route object.
   */

  grouping ip6-route {
    description
      "An IPv6 route.";
    leaf prefix {
      type inet:ipv6-prefix;
      description
        "The route's IPv6 prefix.";
    }

    leaf protocol {
      type frr-route-types:frr-route-types-v6;
      description
        "The protocol owning the route.";
    }

    uses route-common;
  }
  // End of ip6-route

  /*
   * Information about EVPN VNIs
   */

  grouping vni-information {
    choice type-choice {
      case l2 {
        leaf is-layer2 {
          type empty;
          description
            "Information about an L2 VNI.";
        }

        leaf vtep-count {
          type uint32;
          description
            "Number of VTEPs.";
        }
      }

      case l3 {
        leaf is-layer3 {
          type empty;
          description
            "Information about an L3 VNI.";
        }
      }
    }

    leaf vni-id {
      type vni-id-type;
      description
        "The VNI identifier.";
    }

    leaf vxlan-ifname {
      type frr-interface:interface-ref;
      description
        "The VxLAN interface name.";
    }

    leaf mac-count {
      type uint32;
      description
        "Number of valid MACs.";
    }

    leaf neighbor-count {
      type uint32;
      description
        "Number of neighbors.";
    }

    leaf vrf {
      type frr-vrf:vrf-ref;
      description
        "The tenant VRF.";
    }

    leaf local-vtep-addr {
      type inet:ipv4-address;
      description
        "The local VTEP IP address.";
    }
  }

  /*
   * Detailed EVPN VNI information for L2.
   */

  grouping vni-l2-detail {
    leaf if-index {
      type uint32;
      description
        "The VxLAN ifindex.";
    }

    leaf advertise-gw {
      type empty;
      description
        "The gateway MAC-IP is being advertised.";
    }

    leaf mcast-group {
      type rt-types:ipv4-multicast-group-address;
      description
        "The VNI multicast group for BUM traffic.";
    }

    list remote-vtep-list {
      leaf remote-vtep {
        type inet:ipv4-address;
        description
          "The remote VTEP IP address.";
      }

      leaf vtep-flood {
        type vni-vtep-flood-type;
      }
    }
  }

  /*
   * Detailed EVPN VNI information for L3.
   */

  grouping vni-l3-detail {
    leaf svi-interface {
      type frr-interface:interface-ref;
      description
        "The SVI interface.";
    }

    leaf is-up {
      type empty;
      description
        "The state is active.";
    }

    leaf prefix-only {
      type empty;
      description
        "Prefix routes only";
    }

    leaf router-mac {
      type yang:mac-address;
      description
        "The VNI Router MAC address.";
    }

    list vni-list {
      description
        "A list of the associated L2 VNIs.";
      leaf vni-id {
        type vni-id-type;
        description
          "An L2 VNI identifier.";
      }
    }
  }

  /*
   * Debug options
   */

  grouping zebra-debugs {
    leaf debug-events {
      type boolean;
      description
        "Debug ZAPI events.";
    }

    leaf debug-zapi-send {
      type boolean;
      description
        "Debug ZAPI messages sent.";
    }

    leaf debug-zapi-recv {
      type boolean;
      description
        "Debug ZAPI messages received.";
    }

    leaf debug-zapi-detail {
      type boolean;
      description
        "Debug ZAPI details.";
    }

    leaf debug-kernel {
      type boolean;
      description
        "Debug kernel events.";
    }

    leaf debug-kernel-msg-send {
      type boolean;
      description
        "Debug kernel messages sent.";
    }

    leaf debug-kernel-msg-recv {
      type boolean;
      description
        "Debug kernel messages received.";
    }

    leaf debug-rib {
      type boolean;
      description
        "Debug RIB processing.";
    }

    leaf debug-rib-detail {
      type boolean;
      description
        "Debug RIB processing details.";
    }

    leaf debug-fpm {
      type boolean;
      description
        "Debug the FIB Push Interface subsystem.";
    }

    leaf debug-nht {
      type boolean;
      description
        "Debug Nexthop-tracking.";
    }

    leaf debug-nht-detail {
      type boolean;
      description
        "Debug Nexthop-tracking details.";
    }

    leaf debug-mpls {
      type boolean;
      description
        "Debug MPLS.";
    }

    leaf debug-vxlan {
      type boolean;
      description
        "Debug VxLAN.";
    }

    leaf debug-pw {
      type boolean;
      description
        "Debug pseudowires.";
    }

    leaf debug-dplane {
      type boolean;
      description
        "Debug the dataplane subsystem.";
    }

    leaf debug-dplane-detail {
      type boolean;
      description
        "Debug dataplane subsystem details.";
    }

    leaf debug-mlag {
      type boolean;
      description
        "Debug MLAG.";
    }
  }

  grouping ribs {
    container ribs {
      config false;
      description
        "RIBs supported by FRR.";
      list rib {
        key "afi-safi-name table-id";
        leaf afi-safi-name {
          type identityref {
            base frr-rt:afi-safi-type;
          }
          description
            "AFI, SAFI name.";
        }

        leaf table-id {
          type uint32;
          description
            "Routing Table id (default id - 254).";
        }

        list route {
          key "prefix";
          leaf prefix {
            type inet:ip-prefix;
            description
              "The route's prefix.";
          }

          list route-entry {
            key "protocol";
            leaf protocol {
              type frr-route-types:frr-route-types;
              description
                "The protocol owning the route.";
            }

            leaf instance {
              type uint16;
              must "../protocol = \"ospf\"";
              description
                "Retrieve routes from a specific OSPF instance.";
            }

            uses route-common;
          }
        }
      }
    }
  }

  grouping vrf-vni-mapping {
    description
      "EVPN L3-VNI mapping corresponding to a VRF.";
    leaf l3vni-id {
      type vni-id-type;
      description
        "EVPN L3-VNI id to map to the VRF.";
    }

    leaf prefix-only {
      type boolean;
      default "false";
      description
        "EVPN asymmetric mode advertise prefix routes only.";
    }
  }

  // End of zebra container
  /*
   * RPCs
   */

  rpc get-route-information {
    description
      "Retrieve IPv4 or IPv6 unicast routes.";
    input {
      choice ip-type {
        case v4 {
          leaf ipv4 {
            type empty;
            mandatory true;
            description
              "Retrieve IPv4 routes.";
          }

          leaf prefix-v4 {
            type inet:ipv4-prefix;
            description
              "Retrieve routes matching a specific prefix.";
          }

          leaf supernets-only {
            type empty;
            description
              "Skip routes that are subnets of classful prefix sizes.";
          }
        }

        case v6 {
          leaf ipv6 {
            type empty;
            mandatory true;
            description
              "Retrieve IPv6 routes.";
          }

          leaf prefix-v6 {
            type inet:ipv6-prefix;
            description
              "Retrieve routes matching a specific prefix.";
          }
        }
      }

      choice vrf-choice {
        case single {
          leaf vrf {
            type frr-vrf:vrf-ref;
            description
              "Retrieve routes in a non-default vrf.";
          }
        }

        case all {
          leaf all-vrfs {
            type empty;
            description
              "Retrieve routes from all vrfs.";
          }
        }
      }

      leaf fib-routes {
        type empty;
        description
          "Retrieve FIB routes rather than RIB routes.";
      }

      leaf table-id {
        type uint32 {
          range "1..4294967295";
        }
        description
          "Routing table id to retrieve.";
      }

      leaf protocol {
        type frr-route-types:frr-route-types-v4;
        description
          "Retrieve routes from a specific protocol daemon.";
      }

      leaf ospf-instance {
        type uint32 {
          range "1..65535";
        }
        must "../protocol = \"ospf\"";
        description
          "Retrieve routes from a specific OSPF instance.";
      }

      choice detail {
        case det {
          leaf include-detail {
            type empty;
            description
              "Include detailed information.";
          }
        }

        case summ {
          leaf summary {
            type empty;
            description
              "Include summary information only.";
          }
        }
      }
    }
    // End of input
    output {
      choice route-list {
        case v4 {
          container routes-v4 {
            description
              "IPv4 route information.";
            list route {
              uses ip4-route;
            }
          }
        }

        case v6 {
          container routes-v6 {
            description
              "IPv6 route information.";
            list route {
              uses ip6-route;
            }
          }
        }
      }
    }
    // End of output
  }

  // End get-route-information

  rpc get-v6-mroute-info {
    description
      "Retrieve IPv6 multicast routes.";
    input {
      choice vrf-choice {
        case single {
          leaf vrf {
            type frr-vrf:vrf-ref;
            description
              "Retrieve routes in a non-default vrf.";
          }
        }

        case all {
          leaf all-vrfs {
            type empty;
            description
              "Retrieve routes from all vrfs.";
          }
        }
      }
    }

    output {
      container routes {
        description
          "IPv6 mcast route information.";
        list route {
          uses ip6-route;
        }
      }
    }
  }

  // End get-v6-mroute-info

  rpc get-vrf-info {
    description
      "Retrieve VRF information; the default VRF is elided.";
    // Note: no input clause.
    output {
      list vrf-list {
        leaf name {
          type frr-vrf:vrf-ref;
          description
            "The VRF name";
        }

        leaf is-user-config {
          type empty;
          description
            "The VRF was configured by an admin.";
        }

        leaf vrf-id {
          type uint32;
          description
            "The VRF id.";
        }

        choice vrf-type {
          case inactive {
            leaf is-inactive {
              type empty;
              description
                "The VRF is inactive.";
            }
          }

          case netns {
            leaf netns-name {
              type string;
              description
                "The net namespace name associated with the VRF.";
            }
          }

          case table {
            leaf table-id {
              type uint32;
              description
                "The table-id associated with the VRF.";
            }
          }
        }
      }
    }
  }

  // End get-vrf-info

  rpc get-vrf-vni-info {
    description
      "Retrieve mappings between EVPN VNI and VRF.";
    // Note: no input clause.
    output {
      list vrf-vni-list {
        leaf vrf-name {
          type frr-vrf:vrf-ref;
          description
            "The VRF name.";
        }

        leaf vni-id {
          type vni-id-type;
          description
            "The EVPN VNI.";
        }

        leaf vxlan-if-name {
          type frr-interface:interface-ref;
          description
            "The VxLAN interface name.";
        }

        leaf svi-if-name {
          type frr-interface:interface-ref;
          description
            "The SVI interface name.";
        }

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

        leaf is-up {
          type empty;
          description
            "The state is active.";
        }
      }
    }
  }

  // End get-vrf-vni-info

  rpc get-evpn-info {
    description
      "Retrieve global information about EVPN.";
    // Note: No input clause.
    output {
      leaf l2vni-count {
        type uint32;
        description
          "Number of L2 VNIs.";
      }

      leaf l3vni-count {
        type uint32;
        description
          "Number of L3 VNIs.";
      }

      leaf advertise-gateway {
        type empty;
        description
          "Advertise the gateway MAC-IP.";
      }

      leaf advertise-svi {
        type empty;
        description
          "Advertise SVI MAC-IP.";
      }

      leaf dup-detect {
        type empty;
        description
          "Duplicate address detection is enabled.";
      }

      leaf dad-max-moves {
        type uint32;
        description
          "Maximum moves allowed before address is considered duplicate.";
      }

      leaf dad-timeout {
        type uint32;
        units "seconds";
        description
          "Duplicate address detection timeout.";
      }

      leaf dad-freeze {
        type empty;
        description
          "Duplicate address detection freeze enabled.";
      }

      choice dad-freeze-choice {
        case freeze-permanent {
          leaf dad-freeze-perm {
            type empty;
            description
              "Duplicate address detection freeze is permanent.";
          }
        }

        case freeze-time {
          leaf dad-freeze-time {
            type uint32;
            units "seconds";
            description
              "Duplicate address detection freeze timer.";
          }
        }
      }
    }
  }

  // End get-evpn-info

  rpc get-vni-info {
    // If no vni is specified, retrieve global list.
    input {
      choice vni-choice {
        default "all-vnis";
        case all-vnis {
          leaf all-vnis {
            type empty;
            description
              "Retrieve information about all VNIs.";
          }
        }

        case single-vni {
          leaf vni-id {
            type vni-id-type;
            description
              "Retrieve information about a specific EVPN VNI.";
          }
        }
      }

      leaf detailed-info {
        type empty;
        description
          "Retrieve detailed information.";
      }
    }

    output {
      list vni-list {
        description
          "Information about EVPN VNI objects.";
        uses vni-information;

        choice detail-choice {
          case l2 {
            description
              "Detailed L2 information.";
            uses vni-l2-detail;
          }

          case l3 {
            description
              "Detailed L3 information.";
            uses vni-l3-detail;
          }
        }
      }
    }
  }

  // End get-vni-info

  rpc get-evpn-vni-rmac {
    description
      "Retrieve information about VxLAN VNI RMACs.";
    input {
      choice vni-choice {
        default "all-vnis";
        case all-vnis {
          leaf all-vnis {
            type empty;
            description
              "Retrieve information about all VNIs.";
          }
        }

        case single-vni {
          leaf vni-id {
            type vni-id-type;
            description
              "Retrieve information about a specific EVPN VNI.";
          }

          leaf vni-rmac {
            type yang:mac-address;
            description
              "A single RMAC address.";
          }
        }
      }
    }

    output {
      list rmac-info-list {
        leaf rmac {
          type yang:mac-address;
          description
            "The RMAC address.";
        }

        leaf remote-vtep {
          type inet:ipv4-address;
          description
            "The remote VTEP IP address.";
        }

        leaf refcount {
          type uint32;
          description
            "The refcount of the RMAC.";
        }

        list prefix-list {
          leaf prefix-item {
            type inet:ip-prefix;
            description
              "IP prefixes associated with the RMAC.";
          }
        }
      }
    }
  }

  // End get-evpn-vni-rmac

  rpc get-evpn-vni-nexthops {
    description
      "Retrieve information about EVPN nexthops.";
    input {
      choice vni-choice {
        default "all-vnis";
        case all-vnis {
          leaf all-vnis {
            type empty;
            description
              "Retrieve information about all VNIs.";
          }
        }

        case single-vni {
          leaf vni-id {
            type vni-id-type;
            description
              "Retrieve information about a specific EVPN VNI.";
          }

          leaf vni-ipaddr {
            type inet:ip-address;
            description
              "A single host IP address (v4 or v6).";
          }
        }
      }
    }

    output {
      list nh-info-list {
        leaf ip-addr {
          type inet:ip-address;
          description
            "The nexthop IP address.";
        }

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

        leaf refcount {
          type uint32;
          description
            "The refcount of the RMAC.";
        }

        list prefix-list {
          leaf prefix-item {
            type inet:ip-prefix;
            description
              "IP prefixes associated with the RMAC.";
          }
        }
      }
    }
  }

  // End get-evpn-vni-vteps

  rpc clear-evpn-dup-addr {
    description
      "Clear duplicate address detection state for one or all VNIs.";
    input {
      choice clear-dup-choice {
        case all-case {
          leaf all-vnis {
            type empty;
            description
              "Clear all VNIs.";
          }
        }

        case single-case {
          leaf vni-id {
            type vni-id-type;
            description
              "Clear state for a single EVPN VNI.";
          }

          choice ip-mac-choice {
            description
              "Clear state for a specific MAC or IP address.";
            case ip-case {
              leaf vni-ipaddr {
                type inet:ip-address;
                description
                  "A specific IP address (v4 or v6).";
              }
            }

            case mac-case {
              leaf mac-addr {
                type yang:mac-address;
                description
                  "A specific MAC address.";
              }
            }
          }
        }
      }
    }
  }

  // End clear-evpn-dup-addr

  rpc get-evpn-macs {
    description
      "Retrieve information about EVPN MAC addresses.";
    input {
      choice all-choice {
        default "all-vni";
        case all-vni {
          leaf all-vnis {
            type empty;
            description
              "Retrieve information for all VNIs.";
          }

          choice all-choices {
            case detail-case {
              leaf all-detail {
                type empty;
                description
                  "Include detailed results.";
              }
            }

            case vtep-case {
              leaf all-vtep-addr {
                type inet:ipv4-address;
                description
                  "A single VTEP address.";
              }
            }

            case dup-case {
              leaf all-dup {
                type empty;
                description
                  "Show duplicate addresses.";
              }
            }
          }
        }

        case single-vni {
          leaf vni-id {
            type vni-id-type;
            description
              "Retrieve information for a single VNI.";
          }

          choice single-choices {
            case detail-case {
              leaf single-detail {
                type empty;
                description
                  "Include detailed results.";
              }
            }

            case mac-case {
              leaf single-mac {
                type yang:mac-address;
                description
                  "A specific MAC address.";
              }
            }

            case vtep-case {
              leaf single-vtep {
                type inet:ipv4-address;
                description
                  "A single VTEP address.";
              }
            }

            case dup-case {
              leaf single-dup {
                type empty;
                description
                  "Show duplicate addresses.";
              }
            }
          }
        }
      }
    }
    // End of input section
    output {
      list mac-list {
        leaf mac-addr {
          type yang:mac-address;
          description
            "The MAC address.";
        }

        leaf vni {
          type vni-id-type;
          description
            "The VNI value.";
        }

        leaf local-sequence {
          type uint32;
          description
            "Local sequence number.";
        }

        leaf remote-sequence {
          type uint32;
          description
            "Remote sequence number.";
        }

        leaf dad-count {
          type uint32;
          description
            "Duplicate detection counter.";
        }

        leaf is-duplicate {
          type empty;
          description
            "Duplicate MAC detected.";
        }

        leaf dup-detect-time {
          type unix-timestamp;
          description
            "If a duplicate, the detection time.";
        }

        container dup-detect-started {
          leaf dup-detect-start {
            type unix-timestamp;
            description
              "Duplicate detection process start time.";
          }

          leaf dup-count {
            type uint32;
            description
              "Duplicate detection count.";
          }
        }

        leaf is-auto {
          type empty;
          description
            "This is an Auto MAC.";
        }

        leaf is-sticky {
          type empty;
          description
            "This is a sticky MAC.";
        }

        leaf is-default-gw {
          type empty;
          description
            "This is a default-gateway MAC.";
        }

        leaf is-remote-gw {
          type empty;
          description
            "This is a remote-gateway MAC.";
        }

        list neighbor-list {
          leaf neighbor-addr {
            type inet:ip-address;
            description
              "Neighbor address.";
          }

          leaf is-active {
            type empty;
            description
              "Neighbor is active.";
          }
        }

        leaf mac-count {
          type uint32;
          description
            "Number of MACs (local and remote).";
        }

        choice local-rem-choice {
          case local-case {
            leaf intf {
              type frr-interface:interface-ref;
              description
                "The local interface name.";
            }

            leaf vlan {
              type uint32;
              description
                "A VLAN id.";
            }
          }

          case remote-case {
            leaf vtep-addr {
              type inet:ipv4-address;
              description
                "The remote VTEP IP address.";
            }
          }
        }
      }
    }
  }

  // End get-evpn-macs

  rpc get-evpn-arp-cache {
    description
      "Retrieve information about EVPN neighbor cache entries.";
    input {
      choice all-choice {
        default "all-vni";
        case all-vni {
          leaf all-vnis {
            type empty;
            description
              "Retrieve information for all VNIs.";
          }

          choice all-choices {
            case detail-case {
              leaf all-detail {
                type empty;
                description
                  "Include detailed results.";
              }
            }

            case dup-case {
              leaf all-dup {
                type empty;
                description
                  "Show duplicates.";
              }
            }
          }
        }

        case single-vni {
          leaf vni-id {
            type vni-id-type;
            description
              "Retrieve information for a single VNI.";
          }

          choice single-choices {
            case vtep-case {
              leaf single-vtep {
                type inet:ipv4-address;
                description
                  "A single VTEP address.";
              }
            }

            case neighbor-case {
              leaf neighbor-addr {
                type inet:ip-address;
                description
                  "A single neighbor address.";
              }
            }

            case dup-case {
              leaf single-dup {
                type empty;
                description
                  "Show duplicates.";
              }
            }
          }
        }
      }
    }
    // End input section
    output {
      list vni-list {
        container vni-container {
          description
            "Information for one VNI.";
          leaf vni-id {
            type vni-id-type;
            description
              "The VNI id.";
          }

          list neigh-list {
            description
              "Information about a VNI's neighbor cache.";
            leaf mac-addr {
              type yang:mac-address;
              description
                "A neighbor MAC address.";
            }

            leaf ip-addr {
              type inet:ip-address;
              description
                "A neighbor IP address.";
            }

            leaf state-active {
              type empty;
              description
                "Indicates whether the entry is active.";
            }

            choice local-remote-choice {
              case local-case {
                leaf is-local {
                  type empty;
                  description
                    "The entry is local.";
                }
              }

              case remote-case {
                leaf is-remote {
                  type empty;
                  description
                    "The entry is remote.";
                }
              }
            }

            leaf is-dup {
              type empty;
              description
                "The entry is a detected duplicate.";
            }

            leaf is-default-gw {
              type empty;
              description
                "The entry is a default gateway.";
            }

            leaf is-router {
              type empty;
              description
                "The entry is a router.";
            }

            leaf local-sequence {
              type uint32;
              description
                "The local sequence number.";
            }

            leaf remote-sequence {
              type uint32;
              description
                "The remote sequence number.";
            }

            leaf remote-vtep {
              type inet:ipv4-address;
              description
                "The remote VTEP address.";
            }
          }
        }
      }
    }
  }

  // End get-evpn-arp-cache

  rpc get-pbr-ipset {
    input {
      leaf name {
        type string {
          length "1..32";
        }
        description
          "An optional specific IPset name.";
      }
    }

    output {
      list ipset-list {
        leaf name {
          type string {
            length "1..32";
          }
          description
            "The IPset name.";
        }

        leaf ipset-type {
          type enumeration {
            enum "net-net" {
              value 1;
              description
                "";
            }
            enum "net-port-net" {
              value 2;
              description
                "";
            }
            enum "net-port" {
              value 3;
              description
                "";
            }
            enum "net" {
              value 4;
              description
                "";
            }
          }
        }

        leaf src-prefix {
          type inet:ip-prefix;
          description
            "";
        }

        leaf dest-prefix {
          type inet:ip-prefix;
          description
            "";
        }

        leaf src-port {
          type inet:port-number;
          description
            "";
        }

        leaf dest-port {
          type inet:port-number;
          description
            "";
        }

        choice proto-choice {
          description
            "Filter UDP/TCP only, or a specific protocol number.";
          case udp-tcp-case {
            leaf is-udp-tcp {
              type empty;
              description
                "Filter TCP/UDP ports only.";
            }
          }

          case proto-case {
            leaf proto {
              type uint32;
              description
                "Filter a specific protocol number.";
            }
          }
        }

        container icmp-info {
          description
            "Additional information for ICMP filters.";
          leaf type-min {
            type uint8;
            description
              "";
          }

          leaf type-max {
            type uint8;
            description
              "";
          }

          leaf code-min {
            type uint8;
            description
              "";
          }

          leaf code-max {
            type uint8;
            description
              "";
          }
        }

        container ipset-stats {
          leaf is-unique {
            type empty;
            description
              "";
          }

          leaf packet-counter {
            type uint64;
            description
              "";
          }

          leaf bytes-counter {
            type uint64;
            description
              "";
          }
        }
      }
    }
  }

  // End get-pbr-ipset

  rpc get-pbr-iptable {
    input {
      leaf name {
        type string {
          length "1..32";
        }
        description
          "An optional single IPtable name.";
      }
    }

    output {
      list iptable-list {
        leaf name {
          type string {
            length "1..32";
          }
          description
            "The IPtable name.";
        }

        leaf unique-val {
          type uint32;
          description
            "";
        }

        choice action-choice {
          description
            "The table action.";
          case drop-case {
            leaf action-drop {
              type empty;
              description
                "";
            }
          }

          case redirect-case {
            leaf action-redirect {
              type empty;
              description
                "";
            }
          }
        }

        leaf min-packet {
          type uint32;
          description
            "";
        }

        leaf max-packet {
          type uint32;
          description
            "";
        }

        leaf lookup-src-port {
          type empty;
          description
            "";
        }

        leaf lookup-dst-port {
          type empty;
          description
            "";
        }

        leaf tcp-flags {
          type uint16;
          description
            "";
        }

        leaf tcp-flags-mask {
          type uint16;
          description
            "";
        }

        leaf protocol-val {
          type uint32;
          description
            "An IP protocol number.";
        }

        container dscp-info {
          leaf dscp-value {
            type uint32;
            description
              "A DSCP value to match.";
          }

          leaf invert-match {
            type empty;
            description
              "If set, exclude the specified value";
          }
        }

        container fragment-info {
          leaf fragment-val {
            type uint32;
            description
              "An IP fragment value.";
          }

          leaf invert-match {
            type empty;
            description
              "If set, exclude the specified value.";
          }
        }

        container iptable-stats {
          leaf packet-counter {
            type uint64;
            description
              "";
          }

          leaf bytes-counter {
            type uint64;
            description
              "";
          }
        }

        container rule-info {
          description
            "Information about a rule, for redirect tables.";
          leaf table-id {
            type uint32;
            description
              "The rule table id.";
          }

          leaf table-fwmark {
            type uint32;
            description
              "The firewall mark for the rule.";
          }
        }
      }
    }
  }

  // End get-pbr-iptable
  /*
   * Handy 'all-at-once' api to retrieve debugs
   */

  rpc get-debugs {
    output {
      uses zebra-debugs;
    }
  }

  // End get-debugs

  augment "/frr-interface:lib/frr-interface:interface" {
    description
      "Extends interface model with Zebra-related parameters.";
    container zebra {
      list ip-addrs {
        key "address-family ip-prefix";
        description
          "IP prefixes for an interface.";
        uses frr-rt:address-family {
          description
            "Address family of the RIB.";
        }

        leaf ip-prefix {
          type inet:ip-prefix;
          description
            "IP address prefix.";
        }

        leaf label {
          type string;
          description
            "Optional string label for the address.";
        }

        leaf ip4-peer {
          when "derived-from-or-self(../address-family, 'frr-rt:ipv4')";
          type inet:ipv4-prefix;
          description
            "Peer prefix, for peer-to-peer interfaces.";
        }
      }

      leaf multicast {
        type boolean;
        description
          "Multicast flag for the interface.";
      }

      leaf link-detect {
        type boolean;
        description
          "Link-detection for the interface.";
      }

      leaf shutdown {
        type boolean;
        description
          "Interface admin status.";
      }

      leaf mpls {
        type boolean;
        description
          "Interface MPLS status.";
      }

      leaf bandwidth {
        type uint32 {
          range "1..100000";
        }
        description
          "Link bandwidth informational parameter, in megabits.";
      }
      container link-params {
        description
          "link-params for Traffic-Engineering (TE) use in IGP extensions.";
        choice admin-group-mode {
          description "Admin-group mode";
          case legacy {
            description
              "Legacy mode. Only support standard admin-group (RFC3630/5305/5329)";
            leaf legacy-admin-group {
              description "Admin-Group value";
              type uint32;
            }
          }
          case affinity {
            container affinities {
              leaf-list affinity {
                type string;
                max-elements "256";
                description
                  "Array of Attribute Names";
              }
            }
          }
        }
        leaf affinity-mode {
          description
            "Affinity mode";
          default "extended";
          type enumeration {
              enum extended {
              value 0;
              description
                "Extended Admin-Group only (RFC7308)";
            }
            enum standard {
            value 1;
              description
                "Standard Admin-Group only (RFC3630/5305/5329)";
            }
            enum both {
              value 2;
              description
                "Standard and extended Admin-Group";
            }
          }
        }
        // TODO -- other link-params options
        // for (experimental/partial TE use in IGP extensions)
      }
      container state {
        config false;
        description
          "Operational data.";
        leaf up-count {
          type uint16;
          description
            "Interface Up count.";
        }

        leaf down-count {
          type uint16;
          description
            "Interface Down count.";
        }

        leaf zif-type {
          type identityref {
            base zebra-interface-type;
          }
          description
            "zebra interface type.";
        }

        leaf ptm-status {
          type string;
          default "disabled";
          description
            "Interface PTM status.";
        }

        leaf vlan-id {
          type uint16 {
            range "1..4094";
          }
          description
            "A VLAN id.";
        }

        leaf vni-id {
          type vni-id-type;
        }

        leaf remote-vtep {
          type inet:ipv4-address;
          description
            "The remote VTEP IP address.";
        }

        leaf mcast-group {
          type rt-types:ipv4-multicast-group-address;
          description
            "The VNI multicast group for BUM traffic.";
        }
      }
    }
  }

  augment "/frr-vrf:lib/frr-vrf:vrf" {
    description
      "Extends VRF model with Zebra-related parameters.";
    container zebra {
      description
        "Zebra's vrf specific configuration and operational model.";
      uses ribs;

      uses vrf-vni-mapping;
    }
  }

  augment "/frr-vrf:lib/frr-vrf:vrf/frr-zebra:zebra/ribs/rib/route/route-entry/nexthop-group/nexthop" {
    uses frr-nh:frr-nexthop-operational;
  }

  /*
   * Main zebra container
   */

  container zebra {
    description
      "Data model for the Zebra daemon.";
    leaf mcast-rpf-lookup {
      type frr-zebra:mcast-rpf-lookup-mode;
      default "mrib-then-urib";
      description
        "Multicast RPF lookup behavior.";
    }
    leaf ip-forwarding {
      type boolean;
      description
        "IP forwarding status.";
    }
    leaf ipv6-forwarding {
      type enumeration {
        enum unknown {
          value -1;
          description
            "Unknown state.";
        }
        enum off {
          value 0;
          description
            "IPv6 forwarding disabled.";
        }
        enum on {
          value 1;
          description
            "IPv6 forwarding enabled.";
        }
      }
      description
        "IPv6 forwarding status.";
    }
    leaf workqueue-hold-timer {
      type uint32 {
        range "0..10000";
      }
      units "milliseconds";
      default "10";
      description
        "Work-queue processing hold timer, in milliseconds.";
    }
    leaf zapi-packets {
      type uint32 {
        range "1..10000";
      }
      default "1000";
      description
        "Number of ZAPI packets to process before relinquishing
         the main thread.";
    }
    container import-kernel-table {
      description
        "Parameters to use when importing IPv4 routes from a non-main kernel
         routing table.";
      leaf table-id {
        type uint32 {
          range "1..252";
        }
        description
          "The kernel table id.";
      }
      leaf distance {
        type uint32 {
          range "1..255";
        }
        default "15";
        description
          "The admin distance to use for imported routes.";
      }
      leaf route-map {
        type frr-route-map:route-map-ref;
        description
          "A route-map to filter imported routes.";
      }
    }
    leaf allow-external-route-update {
      type empty;
      description
        "Allow FRR-controlled routes to be overwritten by external processes";
    }
    leaf dplane-queue-limit {
      type uint32 {
        range "0..10000";
      }
      default "200";
      description
        "Limit on the number of updates queued to the dataplane subsystem.";
    }
    /*
     * Debug options
     */
    container debugs {
      uses zebra-debugs;
    }
    /* End of debugs */
    /*
     * End of configuration attributes
     */
    /*
     * Operational data.
     */
    container state {
      config false;
      description
        "Operational data.";
    }
    // End of operational / state container
  }
}