module Cisco-IOS-XR-ipv4-io-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-ipv4-io-oper";

    prefix ipv4-io-oper;

    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-ipv4-io-oper-sub2 {
      revision-date "2019-10-01";
    }
    include Cisco-IOS-XR-ipv4-io-oper-sub1 {
      revision-date "2019-10-01";
    }

    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 ipv4-io package operational data.

This module contains definitions
for the following management objects:
  ipv4-network: IPv4 network operational data

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

    revision "2019-10-01" {
      description
        "Updated brief and detail containers for node related interfaces.";
    }

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

    revision "2018-08-01" {
      description "Removed empty groupings.";
    }

    revision "2015-10-20" {
      description
        "this schema file has all the latest changes.";
    }

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

    semver:module-version "1.1.0";
    semver:module-version "1.0.1";

    container ipv4-network {
      config false;
      description
        "IPv4 network operational data";
      container nodes {
        description
          "Node-specific IPv4 network operational data";
        list node {
          key "node-name";
          description
            "IPv4 network operational data for a particular
node";
          container interface-data {
            description
              "IPv4 network operational interface data";
            container vrfs {
              description
                "VRF specific IPv4 network operational
interface data";
              list vrf {
                key "vrf-name";
                description
                  "VRF name of an interface belong to";
                container briefs {
                  description
                    "Brief interface IPv4 network operational
data for a node";
                  list brief {
                    key "interface-name";
                    description
                      "Brief interface IPv4 network operational
data for an interface";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "The name of the interface";
                    }

                    leaf primary-address {
                      type inet:ipv4-address;
                      description
                        "Ipv4 primary address of the interface";
                    }

                    leaf vrf-id {
                      type uint32;
                      description
                        "VRF ID of the interface";
                    }

                    leaf vrf-name {
                      type string;
                      description
                        "VRF name of the interface";
                    }

                    leaf line-state {
                      type Ipv4-ma-oper-line-state;
                      description
                        "Line state of the interface";
                    }
                  }  // list brief
                }  // container briefs

                container details {
                  description
                    "Detail interface IPv4 network operational
data for a node";
                  list detail {
                    key "interface-name";
                    description
                      "Detail interface IPv4 network operational
data for an interface";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "The name of the interface";
                    }

                    container acl {
                      description
                        "ACLs configured on the interface";
                      leaf inbound {
                        type string;
                        description
                          "ACL applied to incoming packets";
                      }

                      leaf outbound {
                        type string;
                        description
                          "ACL applied to outgoing packets";
                      }

                      leaf common-in-bound {
                        type string;
                        description
                          "Common ACL applied to incoming packets";
                      }

                      leaf common-out-bound {
                        type string;
                        description
                          "Common ACL applied to outgoing packets";
                      }
                    }  // container acl

                    container multi-acl {
                      description
                        "Multi ACLs configured on the interface";
                      list inbound {
                        max-elements 5;
                        description
                          "Inbound ACLs";
                        leaf entry {
                          type Str;
                          description
                            "Inbound ACLs";
                        }
                      }  // list inbound

                      list outbound {
                        max-elements 5;
                        description
                          "Outbound ACLs";
                        leaf entry {
                          type Str;
                          description
                            "Outbound ACLs";
                        }
                      }  // list outbound

                      list common {
                        max-elements 5;
                        description
                          "Common ACLs";
                        leaf entry {
                          type Str;
                          description
                            "Common ACLs";
                        }
                      }  // list common
                    }  // container multi-acl

                    container helper-address {
                      description
                        "Helper Addresses configured on the interface";
                      list address-array {
                        description
                          "Helper address";
                        leaf entry {
                          type inet:ipv4-address;
                          description
                            "Helper address";
                        }
                      }  // list address-array
                    }  // container helper-address

                    container rpf {
                      description
                        "RPF config on the interface";
                      leaf enable {
                        type boolean;
                        description
                          "Enable RPF config";
                      }

                      leaf allow-default-route {
                        type boolean;
                        description
                          "Allow Default Route for RPF config";
                      }

                      leaf allow-self-ping {
                        type boolean;
                        description
                          "Allow Self Ping";
                      }

                      leaf mode {
                        type Rpf-mode;
                        description
                          "RPF Mode (loose/strict)";
                      }
                    }  // container rpf

                    container bgp-pa {
                      description
                        "BGP PA config on the interface";
                      container input {
                        description
                          "BGP PA input config";
                        leaf enable {
                          type boolean;
                          description
                            "Enable BGP PA for ingress/egress";
                        }

                        leaf source {
                          type boolean;
                          description
                            "Enable source accouting";
                        }

                        leaf destination {
                          type boolean;
                          description
                            "Enable destination accouting";
                        }
                      }  // container input

                      container output {
                        description
                          "BGP PA output config";
                        leaf enable {
                          type boolean;
                          description
                            "Enable BGP PA for ingress/egress";
                        }

                        leaf source {
                          type boolean;
                          description
                            "Enable source accouting";
                        }

                        leaf destination {
                          type boolean;
                          description
                            "Enable destination accouting";
                        }
                      }  // container output
                    }  // container bgp-pa

                    leaf primary-address {
                      type inet:ipv4-address;
                      description
                        "Ipv4 primary address of the interface";
                    }

                    leaf vrf-id {
                      type uint32;
                      description
                        "VRF ID of the interface";
                    }

                    leaf line-state {
                      type Ipv4-ma-oper-line-state;
                      description
                        "Line state of the interface";
                    }

                    leaf prefix-length {
                      type uint32;
                      description
                        "Prefix length of primary address";
                    }

                    leaf route-tag {
                      type uint32;
                      description
                        "Route tag associated with the primary address (0
= no tag)";
                    }

                    leaf mtu {
                      type uint32;
                      description
                        "IP MTU of the interface";
                    }

                    leaf unreachable {
                      type boolean;
                      description
                        "Are ICMP unreachables sent on the interface?";
                    }

                    leaf redirect {
                      type boolean;
                      description
                        "Are ICMP redirects sent on the interface?";
                    }

                    leaf direct-broadcast {
                      type boolean;
                      description
                        "Are direct broadcasts sent on the interface?";
                    }

                    leaf mask-reply {
                      type boolean;
                      description
                        "Are mask replies sent on the interface?";
                    }

                    leaf rg-id-exists {
                      type boolean;
                      description
                        "Does ICCP RG ID exist on the interface?";
                    }

                    leaf mlacp-active {
                      type boolean;
                      description
                        "Is mLACP state Active (valid if RG ID exists)";
                    }

                    leaf unnumbered-interface-name {
                      type string;
                      description
                        "Name of referenced interface (valid if
unnumbered)";
                    }

                    leaf next-unnumbered-interface-name {
                      type string;
                      description
                        "Name of interface which is also unnum to
same interface where this intf is unnumbered";
                    }

                    leaf proxy-arp-disabled {
                      type boolean;
                      description
                        "Is Proxy ARP disabled on the interface?";
                    }

                    leaf flow-tag-src {
                      type boolean;
                      description
                        "Is BGP Flow Tag Source is enable";
                    }

                    leaf flow-tag-dst {
                      type boolean;
                      description
                        "Is BGP Flow Tag Destination is enable";
                    }

                    leaf config-flags {
                      type uint16;
                      description
                        "IDB configuration flags";
                    }

                    leaf oper-flags {
                      type uint64;
                      description
                        "IDB operational flags";
                    }

                    leaf arm-flags {
                      type uint16;
                      description
                        "IP ARM operation flags";
                    }

                    leaf state-recvd-frm-im {
                      type Ipv4-ma-oper-line-state;
                      description
                        "state as recieved
from IM";
                    }

                    leaf cflct-address {
                      type inet:ipv4-address;
                      description
                        "Conflicated ipv4 address";
                    }

                    leaf client-type {
                      type Ipv4-ma-oper-config;
                      description
                        "Client type for IDB";
                    }

                    leaf is-or-event {
                      type boolean;
                      description
                        "Is OR event for IDB";
                    }

                    leaf or-im-state {
                      type Im-state-enum;
                      description
                        "OR IM state type";
                    }

                    leaf or-im-state-rcvd {
                      type Im-state-enum;
                      description
                        "Rcvd OR IM state type";
                    }

                    leaf or-im-state-constraint {
                      type Im-state-enum;
                      description
                        "Rcvd OR IM constraint state type";
                    }

                    leaf idb-pointer {
                      type uint64;
                      description
                        "idb pointer value";
                    }

                    list multicast-group {
                      description
                        "Multicast groups joined on the interface";
                      leaf group-address {
                        type inet:ipv4-address;
                        description
                          "Address of multicast group";
                      }
                    }  // list multicast-group

                    list secondary-address {
                      description
                        "Secondary addresses on the interface";
                      leaf address {
                        type inet:ipv4-address;
                        description
                          "Ipv4 address";
                      }

                      leaf prefix-length {
                        type uint32;
                        description
                          "Prefix length of address";
                      }

                      leaf route-tag {
                        type uint32;
                        description
                          "Route Tag associated with this address (0 = no
tag)";
                      }
                    }  // list secondary-address
                  }  // list detail
                }  // container details

                leaf vrf-name {
                  type xr:Cisco-ios-xr-string;
                  description "The VRF name";
                }
              }  // list vrf
            }  // container vrfs

            container summary {
              description
                "Summary of IPv4 network operational interface
data on a node";
              container if-up-up {
                description
                  "Number of interfaces (up,up)";
                leaf ip-assigned {
                  type uint32;
                  description
                    "Number of interfaces with explicit addresses";
                }

                leaf ip-unnumbered {
                  type uint32;
                  description
                    "Number of unnumbered interfaces with explicit
addresses";
                }

                leaf ip-unassigned {
                  type uint32;
                  description
                    "Number of unassigned interfaces with explicit
addresses";
                }
              }  // container if-up-up

              container if-up-down {
                description
                  "Number of interfaces (up,down)";
                leaf ip-assigned {
                  type uint32;
                  description
                    "Number of interfaces with explicit addresses";
                }

                leaf ip-unnumbered {
                  type uint32;
                  description
                    "Number of unnumbered interfaces with explicit
addresses";
                }

                leaf ip-unassigned {
                  type uint32;
                  description
                    "Number of unassigned interfaces with explicit
addresses";
                }
              }  // container if-up-down

              container if-down-down {
                description
                  "Number of interfaces (down,down)";
                leaf ip-assigned {
                  type uint32;
                  description
                    "Number of interfaces with explicit addresses";
                }

                leaf ip-unnumbered {
                  type uint32;
                  description
                    "Number of unnumbered interfaces with explicit
addresses";
                }

                leaf ip-unassigned {
                  type uint32;
                  description
                    "Number of unassigned interfaces with explicit
addresses";
                }
              }  // container if-down-down

              container if-shutdown-down {
                description
                  "Number of interfaces (shutdown,down)";
                leaf ip-assigned {
                  type uint32;
                  description
                    "Number of interfaces with explicit addresses";
                }

                leaf ip-unnumbered {
                  type uint32;
                  description
                    "Number of unnumbered interfaces with explicit
addresses";
                }

                leaf ip-unassigned {
                  type uint32;
                  description
                    "Number of unassigned interfaces with explicit
addresses";
                }
              }  // container if-shutdown-down

              leaf if-up-down-basecaps-up {
                type uint32;
                description
                  "Number of interfaces (up,down) with basecaps up";
              }
            }  // container summary

            container interfaces {
              description
                "Interface names with VRF";
              list interface {
                key "interface-name";
                description
                  "Interface names with VRF";
                container vrf-names {
                  description
                    "List of VRF on the interface";
                  list vrf-name {
                    key "vrf-name";
                    description
                      "VRF information on the interface";
                    container detail-data {
                      description
                        "Detail IPv4 network operational data for
an interface";
                      container acl {
                        description
                          "ACLs configured on the interface";
                        leaf inbound {
                          type string;
                          description
                            "ACL applied to incoming packets";
                        }

                        leaf outbound {
                          type string;
                          description
                            "ACL applied to outgoing packets";
                        }

                        leaf common-in-bound {
                          type string;
                          description
                            "Common ACL applied to incoming packets";
                        }

                        leaf common-out-bound {
                          type string;
                          description
                            "Common ACL applied to outgoing packets";
                        }
                      }  // container acl

                      container multi-acl {
                        description
                          "Multi ACLs configured on the interface";
                        list inbound {
                          max-elements 5;
                          description
                            "Inbound ACLs";
                          leaf entry {
                            type Str;
                            description
                              "Inbound ACLs";
                          }
                        }  // list inbound

                        list outbound {
                          max-elements 5;
                          description
                            "Outbound ACLs";
                          leaf entry {
                            type Str;
                            description
                              "Outbound ACLs";
                          }
                        }  // list outbound

                        list common {
                          max-elements 5;
                          description
                            "Common ACLs";
                          leaf entry {
                            type Str;
                            description
                              "Common ACLs";
                          }
                        }  // list common
                      }  // container multi-acl

                      container helper-address {
                        description
                          "Helper Addresses configured on the interface";
                        list address-array {
                          description
                            "Helper address";
                          leaf entry {
                            type inet:ipv4-address;
                            description
                              "Helper address";
                          }
                        }  // list address-array
                      }  // container helper-address

                      container rpf {
                        description
                          "RPF config on the interface";
                        leaf enable {
                          type boolean;
                          description
                            "Enable RPF config";
                        }

                        leaf allow-default-route {
                          type boolean;
                          description
                            "Allow Default Route for RPF config";
                        }

                        leaf allow-self-ping {
                          type boolean;
                          description
                            "Allow Self Ping";
                        }

                        leaf mode {
                          type Rpf-mode;
                          description
                            "RPF Mode (loose/strict)";
                        }
                      }  // container rpf

                      container bgp-pa {
                        description
                          "BGP PA config on the interface";
                        container input {
                          description
                            "BGP PA input config";
                          leaf enable {
                            type boolean;
                            description
                              "Enable BGP PA for ingress/egress";
                          }

                          leaf source {
                            type boolean;
                            description
                              "Enable source accouting";
                          }

                          leaf destination {
                            type boolean;
                            description
                              "Enable destination accouting";
                          }
                        }  // container input

                        container output {
                          description
                            "BGP PA output config";
                          leaf enable {
                            type boolean;
                            description
                              "Enable BGP PA for ingress/egress";
                          }

                          leaf source {
                            type boolean;
                            description
                              "Enable source accouting";
                          }

                          leaf destination {
                            type boolean;
                            description
                              "Enable destination accouting";
                          }
                        }  // container output
                      }  // container bgp-pa

                      leaf primary-address {
                        type inet:ipv4-address;
                        description
                          "Ipv4 primary address of the interface";
                      }

                      leaf vrf-id {
                        type uint32;
                        description
                          "VRF ID of the interface";
                      }

                      leaf line-state {
                        type Ipv4-ma-oper-line-state;
                        description
                          "Line state of the interface";
                      }

                      leaf prefix-length {
                        type uint32;
                        description
                          "Prefix length of primary address";
                      }

                      leaf route-tag {
                        type uint32;
                        description
                          "Route tag associated with the primary address (0
= no tag)";
                      }

                      leaf mtu {
                        type uint32;
                        description
                          "IP MTU of the interface";
                      }

                      leaf unreachable {
                        type boolean;
                        description
                          "Are ICMP unreachables sent on the interface?";
                      }

                      leaf redirect {
                        type boolean;
                        description
                          "Are ICMP redirects sent on the interface?";
                      }

                      leaf direct-broadcast {
                        type boolean;
                        description
                          "Are direct broadcasts sent on the interface?";
                      }

                      leaf mask-reply {
                        type boolean;
                        description
                          "Are mask replies sent on the interface?";
                      }

                      leaf rg-id-exists {
                        type boolean;
                        description
                          "Does ICCP RG ID exist on the interface?";
                      }

                      leaf mlacp-active {
                        type boolean;
                        description
                          "Is mLACP state Active (valid if RG ID exists)";
                      }

                      leaf unnumbered-interface-name {
                        type string;
                        description
                          "Name of referenced interface (valid if
unnumbered)";
                      }

                      leaf next-unnumbered-interface-name {
                        type string;
                        description
                          "Name of interface which is also unnum to
same interface where this intf is unnumbered";
                      }

                      leaf proxy-arp-disabled {
                        type boolean;
                        description
                          "Is Proxy ARP disabled on the interface?";
                      }

                      leaf flow-tag-src {
                        type boolean;
                        description
                          "Is BGP Flow Tag Source is enable";
                      }

                      leaf flow-tag-dst {
                        type boolean;
                        description
                          "Is BGP Flow Tag Destination is enable";
                      }

                      leaf config-flags {
                        type uint16;
                        description
                          "IDB configuration flags";
                      }

                      leaf oper-flags {
                        type uint64;
                        description
                          "IDB operational flags";
                      }

                      leaf arm-flags {
                        type uint16;
                        description
                          "IP ARM operation flags";
                      }

                      leaf state-recvd-frm-im {
                        type Ipv4-ma-oper-line-state;
                        description
                          "state as recieved
from IM";
                      }

                      leaf cflct-address {
                        type inet:ipv4-address;
                        description
                          "Conflicated ipv4 address";
                      }

                      leaf client-type {
                        type Ipv4-ma-oper-config;
                        description
                          "Client type for IDB";
                      }

                      leaf is-or-event {
                        type boolean;
                        description
                          "Is OR event for IDB";
                      }

                      leaf or-im-state {
                        type Im-state-enum;
                        description
                          "OR IM state type";
                      }

                      leaf or-im-state-rcvd {
                        type Im-state-enum;
                        description
                          "Rcvd OR IM state type";
                      }

                      leaf or-im-state-constraint {
                        type Im-state-enum;
                        description
                          "Rcvd OR IM constraint state type";
                      }

                      leaf idb-pointer {
                        type uint64;
                        description
                          "idb pointer value";
                      }

                      list multicast-group {
                        description
                          "Multicast groups joined on the interface";
                        leaf group-address {
                          type inet:ipv4-address;
                          description
                            "Address of multicast group";
                        }
                      }  // list multicast-group

                      list secondary-address {
                        description
                          "Secondary addresses on the interface";
                        leaf address {
                          type inet:ipv4-address;
                          description
                            "Ipv4 address";
                        }

                        leaf prefix-length {
                          type uint32;
                          description
                            "Prefix length of address";
                        }

                        leaf route-tag {
                          type uint32;
                          description
                            "Route Tag associated with this address (0 = no
tag)";
                        }
                      }  // list secondary-address
                    }  // container detail-data

                    container brief-data {
                      description
                        "Brief IPv4 network operational data for
an interface";
                      leaf primary-address {
                        type inet:ipv4-address;
                        description
                          "Ipv4 primary address of the interface";
                      }

                      leaf vrf-id {
                        type uint32;
                        description
                          "VRF ID of the interface";
                      }

                      leaf vrf-name {
                        type string;
                        description
                          "VRF name of the interface";
                      }

                      leaf line-state {
                        type Ipv4-ma-oper-line-state;
                        description
                          "Line state of the interface";
                      }
                    }  // container brief-data

                    leaf vrf-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "The VRF name";
                    }
                  }  // list vrf-name
                }  // container vrf-names

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

          container statistics {
            description
              "Statistical IPv4 network operational data for
a node";
            container traffic {
              description
                "Traffic statistics for a node";
              container ipv4-stats {
                description
                  "IPv4 Network Stats";
                leaf input-packets {
                  type uint32;
                  description
                    "Input packets for ipv4 io traffic";
                }

                leaf received-packets {
                  type uint32;
                  description
                    "Ipv4 packets recieved for ipv4 io traffic";
                }

                leaf format-errors {
                  type uint32;
                  description
                    "Format errors for ipv4 io traffic";
                }

                leaf bad-hop-count {
                  type uint32;
                  description
                    "Bad Hop Count";
                }

                leaf bad-source-address {
                  type uint32;
                  description
                    "Ipv4 source address for ipv4 io traffic is
corrupted";
                }

                leaf bad-header {
                  type uint32;
                  description "Bad Header";
                }

                leaf no-protocol {
                  type uint32;
                  description
                    "Protocol is not present";
                }

                leaf no-gateway {
                  type uint32;
                  description "No Gateway";
                }

                leaf reassemble-input {
                  type uint32;
                  description "RaInput";
                }

                leaf reassembled {
                  type uint32;
                  description
                    "Fragment reassembled";
                }

                leaf reassemble-timeout {
                  type uint32;
                  description
                    "Timeout for fragment reassembly";
                }

                leaf reassemble-max-drop {
                  type uint32;
                  description
                    "Reassembly Max Drop";
                }

                leaf reassemble-failed {
                  type uint32;
                  description
                    "Failure observed during fragment reassembly";
                }

                leaf options-present {
                  type uint32;
                  description
                    "Ipv4 options are present";
                }

                leaf bad-option {
                  type uint32;
                  description "Bad Option";
                }

                leaf unknown-option {
                  type uint32;
                  description
                    "Option for Unknown";
                }

                leaf bad-security-option {
                  type uint32;
                  description
                    "Option for Bad Security";
                }

                leaf basic-security-option {
                  type uint32;
                  description
                    "Option for Basic Security";
                }

                leaf extended-security-option {
                  type uint32;
                  description
                    "Security option is extended for ipv4 io traffic";
                }

                leaf cipso-option {
                  type uint32;
                  description
                    "Option for cipso";
                }

                leaf strict-source-route-option {
                  type uint32;
                  description
                    "Option for strict source route";
                }

                leaf loose-source-route-option {
                  type uint32;
                  description
                    "Option for loose source route";
                }

                leaf record-route-option {
                  type uint32;
                  description
                    "Option for record route";
                }

                leaf sid-option {
                  type uint32;
                  description
                    "Option for SID";
                }

                leaf timestamp-option {
                  type uint32;
                  description
                    "Option for time stamp";
                }

                leaf router-alert-option {
                  type uint32;
                  description
                    "Option for router alert";
                }

                leaf noop-option {
                  type uint32;
                  description
                    "Option for no operation";
                }

                leaf end-option {
                  type uint32;
                  description
                    "Option to end";
                }

                leaf packets-output {
                  type uint32;
                  description
                    "Ipv4 packets output for ipv4 io traffic";
                }

                leaf packets-forwarded {
                  type uint32;
                  description
                    "Ipv4 packets are forwarded";
                }

                leaf packets-fragmented {
                  type uint32;
                  description
                    "ipv4 packets are fragmented";
                }

                leaf fragment-count {
                  type uint32;
                  description
                    "Count for fragments";
                }

                leaf encapsulation-failed {
                  type uint32;
                  description
                    "Observed failure during encapsulation";
                }

                leaf no-router {
                  type uint32;
                  description "No Router";
                }

                leaf packet-too-big {
                  type uint32;
                  description
                    "Size of packet is too big";
                }

                leaf multicast-in {
                  type uint32;
                  description
                    "Recieved multicast packets";
                }

                leaf multicast-out {
                  type uint32;
                  description
                    "Sent multicast packets";
                }

                leaf broadcast-in {
                  type uint32;
                  description
                    "Recieved broadcast packets";
                }

                leaf broadcast-out {
                  type uint32;
                  description
                    "Sent broadcast packets";
                }

                leaf lisp-v4-encap {
                  type uint32;
                  description
                    "Lisp IPv4 encapped packets";
                }

                leaf lisp-v4-decap {
                  type uint32;
                  description
                    "Lisp IPv4 decapped packets";
                }

                leaf lisp-v6-encap {
                  type uint32;
                  description
                    "Lisp IPv6 encapped packets";
                }

                leaf lisp-v6-decap {
                  type uint32;
                  description
                    "Lisp IPv6 decapped packets";
                }

                leaf lisp-encap-error {
                  type uint32;
                  description
                    "Lisp encapsulation errors";
                }

                leaf lisp-decap-error {
                  type uint32;
                  description
                    "Lisp decapsulation errors";
                }
              }  // container ipv4-stats

              container icmp-stats {
                description "ICMP Stats";
                leaf received {
                  type uint32;
                  description
                    "ICMP Received";
                }

                leaf checksum-error {
                  type uint32;
                  description
                    "ICMP Checksum Errors";
                }

                leaf unknown {
                  type uint32;
                  description "ICMP Unknown";
                }

                leaf output {
                  type uint32;
                  description
                    "ICMP Transmitted";
                }

                leaf admin-unreachable-sent {
                  type uint32;
                  description
                    "ICMP Admin Unreachable Sent";
                }

                leaf network-unreachable-sent {
                  type uint32;
                  description
                    "ICMP Network Unreachable Sent";
                }

                leaf host-unreachable-sent {
                  type uint32;
                  description
                    "ICMP Host Unreachable Sent";
                }

                leaf protocol-unreachable-sent {
                  type uint32;
                  description
                    "ICMP Protocol Unreachable Sent";
                }

                leaf port-unreachable-sent {
                  type uint32;
                  description
                    "ICMP Port Unreachable Sent";
                }

                leaf fragment-unreachable-sent {
                  type uint32;
                  description
                    "ICMP Fragment Unreachable Sent";
                }

                leaf admin-unreachable-received {
                  type uint32;
                  description
                    "ICMP Recieved Admin Unreachable";
                }

                leaf network-unreachable-received {
                  type uint32;
                  description
                    "ICMP Recieved Network Unreachable";
                }

                leaf host-unreachable-received {
                  type uint32;
                  description
                    "ICMP Host Unreachable Received";
                }

                leaf protocol-unreachable-received {
                  type uint32;
                  description
                    "ICMP protocol is unreachable";
                }

                leaf port-unreachable-received {
                  type uint32;
                  description
                    "ICMP Port Unreachable Received";
                }

                leaf fragment-unreachable-received {
                  type uint32;
                  description
                    "ICMP fragment is unreachable";
                }

                leaf hopcount-sent {
                  type uint32;
                  description
                    "ICMP Hopcount Sent";
                }

                leaf reassembly-sent {
                  type uint32;
                  description
                    "ICMP Reassembly Sent";
                }

                leaf hopcount-received {
                  type uint32;
                  description
                    "ICMP Hopcount Received";
                }

                leaf reassebly-received {
                  type uint32;
                  description
                    "ICMP Reassembly Received";
                }

                leaf param-error-received {
                  type uint32;
                  description
                    "ICMP Parameter Error Received";
                }

                leaf param-error-send {
                  type uint32;
                  description
                    "ICMP Parameter Error Sent";
                }

                leaf echo-request-sent {
                  type uint32;
                  description
                    "ICMP Echo Request Sent";
                }

                leaf echo-request-received {
                  type uint32;
                  description
                    "ICMP Echo Request Sent";
                }

                leaf echo-reply-sent {
                  type uint32;
                  description
                    "ICMP Echo Reply Sent";
                }

                leaf echo-reply-received {
                  type uint32;
                  description
                    "ICMP Echo Reply Received";
                }

                leaf mask-request-sent {
                  type uint32;
                  description
                    "ICMP Mask Sent";
                }

                leaf mask-request-received {
                  type uint32;
                  description
                    "ICMP Mask Received";
                }

                leaf mask-reply-sent {
                  type uint32;
                  description
                    "ICMP Mask Sent";
                }

                leaf mask-reply-received {
                  type uint32;
                  description
                    "ICMP Mask Received";
                }

                leaf source-quench-received {
                  type uint32;
                  description
                    "ICMP Source Quench";
                }

                leaf redirect-received {
                  type uint32;
                  description
                    "ICMP Redirect Received";
                }

                leaf redirect-send {
                  type uint32;
                  description
                    "ICMP Redirect Sent";
                }

                leaf timestamp-received {
                  type uint32;
                  description
                    "ICMP Timestamp Received";
                }

                leaf timestamp-reply-received {
                  type uint32;
                  description
                    "ICMP Timestamp Reply Received";
                }

                leaf router-advert-received {
                  type uint32;
                  description
                    "ICMP Router Advertisement Received";
                }

                leaf router-solicit-received {
                  type uint32;
                  description
                    "ICMP Router Solicited Received";
                }
              }  // container icmp-stats
            }  // container traffic
          }  // container statistics

          leaf node-name {
            type xr:Node-id;
            description "The node name";
          }
        }  // list node
      }  // container nodes

      container interfaces {
        description
          "IPv4 network operational interface data";
        list interface {
          key "interface-name";
          description
            "Interface names with VRF";
          container vrfs {
            description
              "List of VRF on the interface";
            list vrf {
              key "vrf-name";
              description
                "VRF information on the interface";
              container detail {
                description
                  "Detail IPv4 network operational data for an
interface";
                container acl {
                  description
                    "ACLs configured on the interface";
                  leaf inbound {
                    type string;
                    description
                      "ACL applied to incoming packets";
                  }

                  leaf outbound {
                    type string;
                    description
                      "ACL applied to outgoing packets";
                  }

                  leaf common-in-bound {
                    type string;
                    description
                      "Common ACL applied to incoming packets";
                  }

                  leaf common-out-bound {
                    type string;
                    description
                      "Common ACL applied to outgoing packets";
                  }
                }  // container acl

                container multi-acl {
                  description
                    "Multi ACLs configured on the interface";
                  list inbound {
                    max-elements 5;
                    description
                      "Inbound ACLs";
                    leaf entry {
                      type Str;
                      description
                        "Inbound ACLs";
                    }
                  }  // list inbound

                  list outbound {
                    max-elements 5;
                    description
                      "Outbound ACLs";
                    leaf entry {
                      type Str;
                      description
                        "Outbound ACLs";
                    }
                  }  // list outbound

                  list common {
                    max-elements 5;
                    description
                      "Common ACLs";
                    leaf entry {
                      type Str;
                      description
                        "Common ACLs";
                    }
                  }  // list common
                }  // container multi-acl

                container helper-address {
                  description
                    "Helper Addresses configured on the interface";
                  list address-array {
                    description
                      "Helper address";
                    leaf entry {
                      type inet:ipv4-address;
                      description
                        "Helper address";
                    }
                  }  // list address-array
                }  // container helper-address

                container rpf {
                  description
                    "RPF config on the interface";
                  leaf enable {
                    type boolean;
                    description
                      "Enable RPF config";
                  }

                  leaf allow-default-route {
                    type boolean;
                    description
                      "Allow Default Route for RPF config";
                  }

                  leaf allow-self-ping {
                    type boolean;
                    description
                      "Allow Self Ping";
                  }

                  leaf mode {
                    type Rpf-mode;
                    description
                      "RPF Mode (loose/strict)";
                  }
                }  // container rpf

                container bgp-pa {
                  description
                    "BGP PA config on the interface";
                  container input {
                    description
                      "BGP PA input config";
                    leaf enable {
                      type boolean;
                      description
                        "Enable BGP PA for ingress/egress";
                    }

                    leaf source {
                      type boolean;
                      description
                        "Enable source accouting";
                    }

                    leaf destination {
                      type boolean;
                      description
                        "Enable destination accouting";
                    }
                  }  // container input

                  container output {
                    description
                      "BGP PA output config";
                    leaf enable {
                      type boolean;
                      description
                        "Enable BGP PA for ingress/egress";
                    }

                    leaf source {
                      type boolean;
                      description
                        "Enable source accouting";
                    }

                    leaf destination {
                      type boolean;
                      description
                        "Enable destination accouting";
                    }
                  }  // container output
                }  // container bgp-pa

                leaf primary-address {
                  type inet:ipv4-address;
                  description
                    "Ipv4 primary address of the interface";
                }

                leaf vrf-id {
                  type uint32;
                  description
                    "VRF ID of the interface";
                }

                leaf line-state {
                  type Ipv4-ma-oper-line-state;
                  description
                    "Line state of the interface";
                }

                leaf prefix-length {
                  type uint32;
                  description
                    "Prefix length of primary address";
                }

                leaf route-tag {
                  type uint32;
                  description
                    "Route tag associated with the primary address (0
= no tag)";
                }

                leaf mtu {
                  type uint32;
                  description
                    "IP MTU of the interface";
                }

                leaf unreachable {
                  type boolean;
                  description
                    "Are ICMP unreachables sent on the interface?";
                }

                leaf redirect {
                  type boolean;
                  description
                    "Are ICMP redirects sent on the interface?";
                }

                leaf direct-broadcast {
                  type boolean;
                  description
                    "Are direct broadcasts sent on the interface?";
                }

                leaf mask-reply {
                  type boolean;
                  description
                    "Are mask replies sent on the interface?";
                }

                leaf rg-id-exists {
                  type boolean;
                  description
                    "Does ICCP RG ID exist on the interface?";
                }

                leaf mlacp-active {
                  type boolean;
                  description
                    "Is mLACP state Active (valid if RG ID exists)";
                }

                leaf unnumbered-interface-name {
                  type string;
                  description
                    "Name of referenced interface (valid if
unnumbered)";
                }

                leaf next-unnumbered-interface-name {
                  type string;
                  description
                    "Name of interface which is also unnum to
same interface where this intf is unnumbered";
                }

                leaf proxy-arp-disabled {
                  type boolean;
                  description
                    "Is Proxy ARP disabled on the interface?";
                }

                leaf flow-tag-src {
                  type boolean;
                  description
                    "Is BGP Flow Tag Source is enable";
                }

                leaf flow-tag-dst {
                  type boolean;
                  description
                    "Is BGP Flow Tag Destination is enable";
                }

                leaf config-flags {
                  type uint16;
                  description
                    "IDB configuration flags";
                }

                leaf oper-flags {
                  type uint64;
                  description
                    "IDB operational flags";
                }

                leaf arm-flags {
                  type uint16;
                  description
                    "IP ARM operation flags";
                }

                leaf state-recvd-frm-im {
                  type Ipv4-ma-oper-line-state;
                  description
                    "state as recieved
from IM";
                }

                leaf cflct-address {
                  type inet:ipv4-address;
                  description
                    "Conflicated ipv4 address";
                }

                leaf client-type {
                  type Ipv4-ma-oper-config;
                  description
                    "Client type for IDB";
                }

                leaf is-or-event {
                  type boolean;
                  description
                    "Is OR event for IDB";
                }

                leaf or-im-state {
                  type Im-state-enum;
                  description
                    "OR IM state type";
                }

                leaf or-im-state-rcvd {
                  type Im-state-enum;
                  description
                    "Rcvd OR IM state type";
                }

                leaf or-im-state-constraint {
                  type Im-state-enum;
                  description
                    "Rcvd OR IM constraint state type";
                }

                leaf idb-pointer {
                  type uint64;
                  description
                    "idb pointer value";
                }

                list multicast-group {
                  description
                    "Multicast groups joined on the interface";
                  leaf group-address {
                    type inet:ipv4-address;
                    description
                      "Address of multicast group";
                  }
                }  // list multicast-group

                list secondary-address {
                  description
                    "Secondary addresses on the interface";
                  leaf address {
                    type inet:ipv4-address;
                    description
                      "Ipv4 address";
                  }

                  leaf prefix-length {
                    type uint32;
                    description
                      "Prefix length of address";
                  }

                  leaf route-tag {
                    type uint32;
                    description
                      "Route Tag associated with this address (0 = no
tag)";
                  }
                }  // list secondary-address
              }  // container detail

              container brief {
                description
                  "Brief IPv4 network operational data for an
interface";
                leaf primary-address {
                  type inet:ipv4-address;
                  description
                    "Ipv4 primary address of the interface";
                }

                leaf vrf-id {
                  type uint32;
                  description
                    "VRF ID of the interface";
                }

                leaf vrf-name {
                  type string;
                  description
                    "VRF name of the interface";
                }

                leaf line-state {
                  type Ipv4-ma-oper-line-state;
                  description
                    "Line state of the interface";
                }
              }  // container brief

              leaf vrf-name {
                type xr:Cisco-ios-xr-string;
                description "The VRF name";
              }
            }  // list vrf
          }  // container vrfs

          leaf interface-name {
            type xr:Interface-name;
            description
              "The name of the interface";
          }
        }  // list interface
      }  // container interfaces
    }  // container ipv4-network
  }  // module Cisco-IOS-XR-ipv4-io-oper