submodule Cisco-IOS-XR-ipv4-arp-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-ipv4-arp-oper {
        prefix Cisco-IOS-XR-ipv4-arp-oper;
    }

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

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR ipv4-arp package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-02-11" {
      description
        "IOS XR 6.2.3 revision.
       2021-02-04
         IOS XR 6.2.2 revision.
       2020-12-03
         Adding support for displaying client resync time
       2020-04-22
         adding oper schema support, clinet stats update with cnbng.";
    }

    revision "2019-12-11" {
      description
        "adding oper schema support.";
    }

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

    revision "2018-11-21" {
      description
        "Fixing backward compatibility error in module.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

    revision "2016-12-19" {
      description "IOS XR 6.2.1 revision.";
    }

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

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

    typedef Ip-arp-bag-encap {
      type enumeration {
        enum "none" {
          value 0;
          description "No encapsulation";
        }
        enum "arpa" {
          value 1;
          description "ARPA";
        }
        enum "snap" {
          value 2;
          description "SNAP";
        }
        enum "ieee802-1q" {
          value 3;
          description "802 1Q";
        }
        enum "srp" {
          value 4;
          description "SRP";
        }
        enum "srpa" {
          value 5;
          description "SRPA";
        }
        enum "srpb" {
          value 6;
          description "SRPB";
        }
      }
      description "ARP encapsulation";
    }

    typedef Ip-arp-bag-flags {
      type enumeration {
        enum "flag-none" {
          value 0;
          description "No Flag";
        }
        enum "flag-dynamic" {
          value 1;
          description "Dynamic learnt entry";
        }
        enum "flag-evpn-sync" {
          value 2;
          description "EVPN Synced entry";
        }
        enum "flag-max" {
          value 3;
          description "Maximum Flag number";
        }
      }
      description "ARP flags";
    }

    typedef Ip-arp-bag-state {
      type enumeration {
        enum "state-none" {
          value 0;
          description "No state";
        }
        enum "state-interface" {
          value 1;
          description "Interface";
        }
        enum "state-standby" {
          value 2;
          description "Standby";
        }
        enum "state-static" {
          value 3;
          description "Static";
        }
        enum "state-alias" {
          value 4;
          description "Alias";
        }
        enum "state-mobile" {
          value 5;
          description "Mobile";
        }
        enum "state-incomplete" {
          value 6;
          description "Incomplete";
        }
        enum "state-deleted" {
          value 7;
          description "Deleted";
        }
        enum "state-dynamic" {
          value 8;
          description "Dynamic";
        }
        enum "state-probe" {
          value 9;
          description "Probe";
        }
        enum "state-purge-delayed" {
          value 10;
          description "Purge delayed";
        }
        enum "state-dhcp" {
          value 11;
          description "DHCP installed";
        }
        enum "state-vxlan" {
          value 12;
          description "VXLAN installed";
        }
        enum "state-evpn-sync" {
          value 13;
          description "EVPN-SYNC installed";
        }
        enum "state-sat" {
          value 14;
          description "Satellite installed";
        }
        enum "state-r-sync" {
          value 15;
          description
            "Geo-redundancy sync'ed";
        }
        enum "state-drop-adj" {
          value 16;
          description "Drop adjacency";
        }
        enum "state-stale" {
          value 17;
          description "Stale";
        }
        enum "state-max" {
          value 18;
          description "Maximum state number";
        }
      }
      description "ARP state";
    }

    typedef Ip-arp-bag-media {
      type enumeration {
        enum "media-arpa" {
          value 0;
          description "ARPA";
        }
        enum "media-srp" {
          value 1;
          description "SRP";
        }
        enum "media-unknown" {
          value 2;
          description "Unknown";
        }
      }
      description "ARP media type";
    }

    typedef Arp-peer-status-bag {
      type enumeration {
        enum "state-invalid" {
          value 0;
          description "No State";
        }
        enum "state-init" {
          value 1;
          description "Init State";
        }
        enum "state-retry" {
          value 2;
          description "Retry State";
        }
        enum "state-connect" {
          value 3;
          description "Connect State";
        }
        enum "state-listen" {
          value 4;
          description "Listen State";
        }
        enum "state-reg" {
          value 5;
          description "Register State";
        }
        enum "state-clenaup" {
          value 6;
          description "Register Cleanup";
        }
        enum "state-connected" {
          value 7;
          description "Connected State";
        }
        enum "state-estab" {
          value 8;
          description "Established State";
        }
      }
      description "ARP Sync Peer state";
    }

    typedef Arp-issu-version {
      type enumeration {
        enum "version1" {
          value 0;
          description "Version 1";
        }
        enum "version2" {
          value 1;
          description "Version 2";
        }
      }
      description "Arp issu version";
    }

    typedef Arp-issu-phase {
      type enumeration {
        enum "phase-not-started" {
          value 0;
          description
            "An ISSU event has not started";
        }
        enum "phase-load" {
          value 1;
          description "ISSU Load Phase";
        }
        enum "phase-run" {
          value 2;
          description "ISSU Run Phase";
        }
        enum "phase-completed" {
          value 3;
          description
            "An ISSU event has completed successfully";
        }
        enum "phase-aborted" {
          value 4;
          description
            "An ISSU event has aborted";
        }
      }
      description "Arp issu phase";
    }

    typedef Arp-issu-role {
      type enumeration {
        enum "role-primary" {
          value 0;
          description "Primary role";
        }
        enum "role-secondary" {
          value 1;
          description "Secondary role";
        }
      }
      description "Arp issu role";
    }

    typedef Arp-im-oper-bag {
      type enumeration {
        enum "im-oper-none" {
          value 0;
          description "NONE";
        }
        enum "im-oper-caps-add" {
          value 1;
          description "ADD";
        }
        enum "im-oper-caps-rem" {
          value 2;
          description "REM";
        }
        enum "im-oper-init-data" {
          value 3;
          description "INIT";
        }
        enum "im-oper-last" {
          value 4;
          description "NONE";
        }
      }
      description "ARP IM oper type";
    }

    typedef Im-state {
      type uint32;
      description "Im state";
    }

    typedef Arp-resolution-history-status {
      type enumeration {
        enum "status-none" {
          value 0;
          description "No Status";
        }
        enum "status-resolution-request" {
          value 1;
          description
            "Resolution Request Received";
        }
        enum "status-resolved-reply" {
          value 2;
          description
            "Resolved with ARP reply";
        }
        enum "status-resolved-grat-arp" {
          value 3;
          description
            "Resolved with Grat ARP";
        }
        enum "status-resolved-request" {
          value 4;
          description
            "Resolved with ARP Request";
        }
        enum "status-resolved-lc-sync" {
          value 5;
          description
            "Resolved via a Linecard sync";
        }
        enum
          "status-resolved-lc-sync-purge-delay" {
          value 6;
          description
            "Resolved via a Linecard sync while purge
           delayed";
        }
        enum "status-resolved-client" {
          value 7;
          description
            "Resolved from an ARP API client";
        }
        enum "status-removed-client" {
          value 8;
          description
            "Removed by an ARP API client";
        }
        enum "status-already-resolved" {
          value 9;
          description "Already Resolved";
        }
        enum "status-failed" {
          value 10;
          description "Resolution Failed";
        }
        enum "status-dropped-interface-down" {
          value 11;
          description
            "Dropped because the Interface was down";
        }
        enum
          "status-dropped-broadcast-disabled" {
          value 12;
          description
            "Dropped because the Interface was broadcast
           disabled";
        }
        enum
          "status-dropped-interface-unavailable" {
          value 13;
          description
            "Dropped because the Interface was unavailable
           to arp";
        }
        enum "status-dropped-bad-subnet" {
          value 14;
          description
            "The requested IP address didn't belong to the
           subnet";
        }
        enum
          "status-dropped-dynamic-learning-disabled" {
          value 15;
          description
            "Dynamic learning of ARP entries is disabled on
           the interface";
        }
        enum
          "status-dropped-out-of-subnet-disabled" {
          value 16;
          description
            "Out of Subnet address learning is disabled on
           the interface";
        }
        enum "status-removed-client-sweep" {
          value 17;
          description
            "Removed by an ARP API client during a resync";
        }
        enum "status-added-client" {
          value 18;
          description
            "Added by an ARP API client";
        }
        enum "status-added-v1" {
          value 19;
          description
            "Added by replication from ARP V1 during ISSU";
        }
        enum "status-removed-v1" {
          value 20;
          description
            "Removed by replication from ARP V1 during ISSU";
        }
        enum "status-resolved-peer-sync" {
          value 21;
          description
            "Resolved via a Peer Router sync";
        }
        enum
          "status-dropped-unsolicited-pak" {
          value 22;
          description
            "Learning unsolicited ARP packets is disabled on
           this Interface";
        }
        enum "status-drop-adjacency-added" {
          value 23;
          description
            "Adding drop adjacency entry for the address";
        }
      }
      description
        "Arp resolution history status";
    }

    grouping IP-ARP-TABLE-ENTRY {
      description "IP ARP Table entry";
      leaf media-type {
        type Ip-arp-bag-media;
        description
          "Media type for this entry";
      }

      leaf state {
        type Ip-arp-bag-state;
        description "State of this entry";
      }

      leaf flag {
        type Ip-arp-bag-flags;
        description "Flags of this entry";
      }

      leaf age {
        type uint64;
        description "Age of this entry";
      }

      leaf encapsulation-type {
        type Ip-arp-bag-encap;
        description
          "Type of source encapsulation";
      }

      leaf hardware-length {
        type uint8;
        description "Source MAC length";
      }

      leaf hardware-address {
        type yang:mac-address;
        description "MAC address";
      }
    }  // grouping IP-ARP-TABLE-ENTRY

    grouping IP-ARP-THREAD-ELEMENT-INFO {
      description
        "IP ARP Thread element info";
      leaf thread-q-size {
        type uint32;
        description "TheradQSize";
      }

      leaf peak-q-size {
        type uint32;
        description "PeakQSize";
      }

      leaf msgs-enqueued-count {
        type uint32;
        description "MsgsEnqueuedCount";
      }

      leaf pulse-sent-count {
        type uint32;
        description "PulseSentCount";
      }

      leaf self-pulse-count {
        type uint32;
        description "SelfPulseCount";
      }

      leaf pulse-recvd-count {
        type uint32;
        description "PulseRecvdCount";
      }

      leaf dq-count {
        type uint32;
        description "QCount";
      }

      leaf no-q-count {
        type uint32;
        description "NoQCount";
      }

      leaf qblocked-count {
        type uint32;
        description "QBlocked";
      }

      leaf qreleased-count {
        type uint32;
        description "QReleased";
      }
    }  // grouping IP-ARP-THREAD-ELEMENT-INFO

    grouping IP-ARP-THREAD-NODE-INFO {
      description "IP ARP Thread node info";
      container old-element-info {
        description "OldElementInfo";
        uses IP-ARP-THREAD-ELEMENT-INFO;
      }  // container old-element-info

      container current-element-info {
        description "CurrentElementInfo";
        uses IP-ARP-THREAD-ELEMENT-INFO;
      }  // container current-element-info

      leaf thread-name {
        type string;
        description "NameOfTheThread";
      }
    }  // grouping IP-ARP-THREAD-NODE-INFO

    grouping IP-ARP-THREAD-QUEUE-STATS {
      description
        "IP ARP Thread queue stats";
      leaf total-drop-count {
        type uint64;
        description "TotalDropCount";
      }

      leaf input-packet-drop-count {
        type uint64;
        description "InputPacketDropCount";
      }

      leaf punt-packet-drop-count {
        type uint64;
        description "PuntPacketDropCount";
      }

      leaf unknown-packet-drop-count {
        type uint64;
        description "UnknownPacketDropCount";
      }

      list queue-msg {
        max-elements 6;
        description
          "Queue msgs for ARP thread";
        uses IP-ARP-THREAD-NODE-INFO;
      }  // list queue-msg
    }  // grouping IP-ARP-THREAD-QUEUE-STATS

    grouping ARP-SYNC-ENTRY {
      description
        "ARP Sync Redundancy entry";
      leaf group-id-xr {
        type uint16;
        description "Group ID";
      }

      leaf src-int-name {
        type string {
          length "0..65";
        }
        description "Source Interface Name";
      }

      leaf peer-add {
        type inet:ipv4-address;
        description "Peer IP address";
      }

      leaf peer-status {
        type Arp-peer-status-bag;
        description "Status of Peer";
      }
    }  // grouping ARP-SYNC-ENTRY

    grouping ARP-PAKHIST-ENTRY {
      description "ARP packet history entry";
      leaf idb-interface-name {
        type xr:Interface-name;
        description "Interface";
      }

      leaf sr-caddress {
        type inet:ipv4-address;
        description "Source address";
      }

      leaf ds-taddress {
        type inet:ipv4-address;
        description "Destination address";
      }

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

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

      leaf type {
        type int32;
        description "ARP packet type";
      }

      leaf mode {
        type int32;
        description "Incoming or Outgoing";
      }

      leaf nsec-timestamp {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for entry in nanoseconds since Epoch,
         i.e. since 00:00:00 UTC, January 1, 1970";
      }
    }  // grouping ARP-PAKHIST-ENTRY

    grouping ARP-PAKHIST {
      description "ARP Packet History";
      list arp-entry {
        description
          "ARP packet history array";
        uses ARP-PAKHIST-ENTRY;
      }  // list arp-entry
    }  // grouping ARP-PAKHIST

    grouping ARP-CLIENT-STAT-INFO {
      description "Client statistics";
      leaf client-id-xr {
        type uint32;
        description "ARP client id";
      }

      leaf reg-time {
        type uint64;
        units "nanosecond";
        description
          "Registration timestamp in nano-seconds since
         Epoch, i.e. since 00:00:00 UTC, January 1, 1970";
      }

      leaf unreg-time {
        type uint64;
        units "nanosecond";
        description
          "Un-registration timestamp in nano-seconds since
         Epoch, i.e. since 00:00:00 UTC, January 1, 1970";
      }

      leaf entries-added {
        type uint32;
        description
          "Number of entries added by client";
      }

      leaf entries-deleted {
        type uint32;
        description
          "Number of entries deleted by client";
      }

      leaf send-request {
        type uint32;
        description
          "Number of send request by client";
      }
    }  // grouping ARP-CLIENT-STAT-INFO

    grouping IP-ARP-STATISTICS {
      description
        "IP ARP Statistics information";
      leaf requests-received {
        type uint32;
        description
          "Total ARP requests received";
      }

      leaf replies-received {
        type uint32;
        description
          "Total ARP replies received";
      }

      leaf requests-sent {
        type uint32;
        description
          "Total ARP requests sent";
      }

      leaf replies-sent {
        type uint32;
        description "Total ARP replies sent";
      }

      leaf proxy-replies-sent {
        type uint32;
        description
          "Total Proxy ARP replies sent";
      }

      leaf subscr-requests-received {
        type uint32;
        description
          "Total ARP requests received over subscriber
         interface";
      }

      leaf subscr-replies-sent {
        type uint32;
        description
          "Total ARP replies sent over subscriber interface";
      }

      leaf subscr-replies-gratg-sent {
        type uint32;
        description
          "Total ARP grat replies sent over subscriber
         interface";
      }

      leaf local-proxy-replies-sent {
        type uint32;
        description
          "Total Local Proxy ARP replies sent";
      }

      leaf gratuitous-replies-sent {
        type uint32;
        description
          "Total Gratuituous ARP replies sent";
      }

      leaf resolution-requests-received {
        type uint32;
        description
          "Total ARP request received for resolution";
      }

      leaf resolution-replies-received {
        type uint32;
        description
          "Total ARP replies received for resolution";
      }

      leaf resolution-requests-dropped {
        type uint32;
        description
          "total ARP request dropped for resolution";
      }

      leaf out-of-memory-errors {
        type uint32;
        description
          "Total errors for out of memory";
      }

      leaf no-buffer-errors {
        type uint32;
        description
          "Total errors for no buffer";
      }

      leaf total-entries {
        type uint32;
        description
          "Total ARP entries in the cache";
      }

      leaf dynamic-entries {
        type uint32;
        description
          "Total dynamic entries in the cache";
      }

      leaf static-entries {
        type uint32;
        description
          "Total static entries in the cache";
      }

      leaf alias-entries {
        type uint32;
        description
          "Total alias entries in the cache";
      }

      leaf interface-entries {
        type uint32;
        description
          "Total interface entries in the cache";
      }

      leaf standby-entries {
        type uint32;
        description
          "Total standby entries in the cache";
      }

      leaf dhcp-entries {
        type uint32;
        description
          "Total DHCP entries in the cache";
      }

      leaf vxlan-entries {
        type uint32;
        description
          "Total VXLAN entries in the cache";
      }

      leaf drop-adjacency-entries {
        type uint32;
        description
          "Total drop adjacency entries in the cache";
      }

      leaf ipv4-packets-dropped-node {
        type uint32;
        description
          "Total ip packets droped on this node";
      }

      leaf arp-packet-node-out-of-subnet {
        type uint32;
        description
          "Total ARP packets on node due to out of subnet";
      }

      leaf ipv4-packets-dropped-interface {
        type uint32;
        description
          "Total ip packets droped on this interface";
      }

      leaf arp-packet-interface-out-of-subnet {
        type uint32;
        description
          "Total arp packets on interface due to out of
         subnet";
      }

      leaf arp-packet-unsolicited-packet {
        type uint32;
        description
          "Total unsolicited arp packets dropped";
      }

      leaf idb-structures {
        type uint32;
        description
          "Total idb structures on this node";
      }
    }  // grouping IP-ARP-STATISTICS

    grouping ARP-AIBHIST-ENTRY {
      description "ARP AIB history entry";
      leaf idb-interface-name {
        type xr:Interface-name;
        description "Interface";
      }

      leaf ipv4-address {
        type inet:ipv4-address;
        description
          "Address for adjacency history";
      }

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

      leaf client-id {
        type int32;
        description "Resolving Client ID";
      }

      leaf entry-state {
        type int32;
        description "State of ARP entry";
      }

      leaf protocol {
        type int32;
        description "Protocol ID";
      }

      leaf result {
        type int32;
        description "ARP AIB Update result";
      }

      leaf type {
        type int32;
        description "ARP AIB update type";
      }

      leaf nsec-timestamp {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for entry in nanoseconds since Epoch,
         i.e. since 00:00:00 UTC, January 1, 1970";
      }
    }  // grouping ARP-AIBHIST-ENTRY

    grouping ARP-AIBHIST {
      description "ARP AIB Update History";
      list arp-entry {
        description "ARP AIB history array";
        uses ARP-AIBHIST-ENTRY;
      }  // list arp-entry
    }  // grouping ARP-AIBHIST

    grouping ARP-STATUS-INFO {
      description "ARP Status";
      container all-idb-client-resync-time {
        description
          "Time of last client resync for all IDBs";
        uses BAG-TIMESPEC;
      }  // container all-idb-client-resync-time

      leaf process-start-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the process start time in
         nanoseconds since Epoch, i.e. since 00:00:00 UTC
         , January 1, 1970";
      }

      leaf issu-sync-complete-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the ISSU sync complete in
         nanoseconds since Epoch, i.e. since 00:00:00 UTC
         , January 1, 1970";
      }

      leaf issu-ready-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the ISSU ready declaration in
         nanoseconds since Epoch, i.e. since 00:00:00 UTC
         , January 1, 1970";
      }

      leaf big-bang-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the Big Bang notification time in
         nanoseconds since Epoch, i.e. since 00:00:00 UTC
         , January 1, 1970";
      }

      leaf primary-role-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the change to Primary role
         notification time in nanoseconds since Epoch, i
         .e. since 00:00:00 UTC, January 1, 1970";
      }

      leaf role {
        type Arp-issu-role;
        description
          "The current role of the ARP process";
      }

      leaf phase {
        type Arp-issu-phase;
        description
          "The current ISSU phase of the ARP process";
      }

      leaf version {
        type Arp-issu-version;
        description
          "The current version of the ARP process in the
         context of an ISSU";
      }

      leaf dynamic-entries-recovered-count {
        type uint32;
        description
          "The number of entries that have been recovered
         during ISSU V1 and V2 synchronisation";
      }

      leaf non-operational-entries-count {
        type uint32;
        description
          "The number of entries that are currently
         non-operational in the shadow database";
      }

      leaf interface-handle-translation-failure-count {
        type uint32;
        description
          "The number of interface handle translation
         failures that occurred during the ISSU V1 and V2
         synchronisation";
      }

      leaf issu-ready-issu-mgr-connection {
        type boolean;
        description
          "Whether or not ARP is currently connected to
         ISSU Manager during the ISSU Load Phase";
      }

      leaf issu-ready-im {
        type boolean;
        description
          "Whether or not ARP is in sync with IM during the
         ISSU Load Phase";
      }

      leaf issu-ready-dagr-rib {
        type boolean;
        description
          "Whether or not the ARP DAGR system is in sync
         with the RIB during the ISSU Load Phase";
      }

      leaf issu-ready-entries-replicate {
        type boolean;
        description
          "Whether or not ARP has received all replicated
         entries during the ISSU Load Phase";
      }
    }  // grouping ARP-STATUS-INFO

    grouping BAG-TIMESPEC {
      description
        "Timespec specifying the number of seconds since
       the base time of 00:00:00 GMT, 1 January 1970.";
      leaf seconds {
        type uint32;
        units "second";
        description "Number of seconds";
      }

      leaf nanoseconds {
        type uint32;
        units "nanosecond";
        description "Number of nanoseconds";
      }
    }  // grouping BAG-TIMESPEC

    grouping EVT-HIST-ENTRY {
      description "Event history Entry";
      leaf evt-timestamp {
        type string;
        description
          "The timestamp of the event";
      }

      leaf evt-name {
        type string;
        description "Event name";
      }

      leaf evt-type {
        type uint8;
        description "Event type";
      }

      leaf evt-many {
        type boolean;
        description "Multiple instance flag";
      }

      leaf evt-sticky {
        type boolean;
        description "Sticky flag";
      }

      leaf-list evt-data {
        type uint32;
        description "Optional data";
      }
    }  // grouping EVT-HIST-ENTRY

    grouping EVT-HIST-INFO {
      description "Per object event history";
      leaf evt-class-name {
        type string;
        description "Class name string";
      }

      list evt-entry {
        description "Array of event entries";
        uses EVT-HIST-ENTRY;
      }  // list evt-entry
    }  // grouping EVT-HIST-INFO

    grouping ARP-IDB-INFO {
      description "ARP IDB information";
      container idb-event-history {
        description
          "Event history of Interface";
        uses EVT-HIST-INFO;
      }  // container idb-event-history

      container client-resync-time {
        description
          "Time of last client resync";
        uses BAG-TIMESPEC;
      }  // container client-resync-time

      leaf idb-interface-name {
        type xr:Interface-name;
        description "Interface";
      }

      leaf idb-ip-address {
        type inet:ipv4-address;
        description "Address";
      }

      leaf is-ipv4-unnumbered {
        type boolean;
        description
          "Is the address unnumbered?";
      }

      leaf vrf-id {
        type uint32;
        description
          "VRF that this interface is in";
      }

      leaf vrf-name {
        type string {
          length "0..32";
        }
        description
          "VRF name that this interface is in";
      }

      leaf capsulation-state {
        type Im-state;
        description
          "Capsulation state for IPV4";
      }

      leaf idb-timeout {
        type uint32;
        description
          "Configured timeout value for ARP entries";
      }

      leaf is-dynamic-learning-enabled {
        type boolean;
        description
          "Is dynamic entry learning configured on this
         interface?";
      }

      leaf is-dynamic-learning-local-enabled {
        type boolean;
        description
          "Is dynamic entry learning local configured on
         this interface?";
      }

      leaf is-dynamic-learning-solicited-enabled {
        type boolean;
        description
          "Is dynamic entry learning solicited configured
         on this interface?";
      }

      leaf is-purge-delay-configured {
        type boolean;
        description
          "Presence of Purge delay configuration";
      }

      leaf purge-delay {
        type uint32;
        description
          "The purge delay timeout if configured, otherwise
         set to zero";
      }

      leaf is-idb-forward-referenced {
        type boolean;
        description
          "Is IDB forward referenced for a client";
      }

      leaf is-virtual {
        type boolean;
        description
          "Is this a virtual interface?";
      }

      leaf is-complete {
        type boolean;
        description "Is the IDB complete?";
      }

      leaf is-proxy-enabled {
        type boolean;
        description
          "Is proxy arp enabled on this interface?";
      }

      leaf is-proxy-configured {
        type boolean;
        description
          "Is proxy arp configured on this interface?";
      }

      leaf is-local-proxy-configured {
        type boolean;
        description
          "Is local proxy arp configured on this interface?";
      }

      leaf mpls-capsulation-known {
        type boolean;
        description
          "Is the IPv4 caps added on this interface?";
      }

      leaf ipv4-capsulation-known {
        type boolean;
        description
          "Is the IPv4 caps added on this interface?";
      }

      leaf hardware-address-known {
        type boolean;
        description
          "Is the HW address known for this interface?";
      }

      leaf media-known {
        type boolean;
        description
          "Is the media known for this interface?";
      }

      leaf vlanid-known {
        type boolean;
        description
          "Is the VLAN ID known for this interface?";
      }

      leaf spio-attach-error {
        type uint32;
        description
          "The error returned when attaching to SPIO or
         SUCCESS";
      }

      leaf is-using-spio {
        type boolean;
        description
          "Is SPIO being used as the Packet IO layer for
         this interface?";
      }

      leaf broadcast-disabled {
        type boolean;
        description
          "Is the sending of broadcast packets disabled on
         this interface?";
      }

      leaf client-id {
        type uint32;
        description
          "The client id that has brodacast disabled the
         interface";
      }

      leaf srg-role {
        type uint8;
        description "Srg role for the idb";
      }

      leaf idb-flag {
        type uint32;
        description "ARP IDB flag";
      }

      leaf drop-adj-timeout {
        type uint32;
        description
          "Configured timeout value for drop adjacency";
      }

      leaf idb-flag-ext {
        type uint32;
        description "ARP IDB flag extension";
      }

      leaf oper-progress {
        type Arp-im-oper-bag;
        description
          "Current IM operation in progress";
      }
    }  // grouping ARP-IDB-INFO

    grouping ARP-RESHIST-ENTRY {
      description
        "ARP resolution history entry";
      leaf nsec-timestamp {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for entry in nanoseconds since Epoch,
         i.e. since 00:00:00 UTC, January 1, 1970";
      }

      leaf idb-interface-name {
        type xr:Interface-name;
        description "Interface";
      }

      leaf ipv4-address {
        type inet:ipv4-address;
        description
          "Address for resolution history";
      }

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

      leaf status {
        type Arp-resolution-history-status;
        description "Resolution status";
      }

      leaf client-id {
        type int32;
        description "Resolving Client ID";
      }

      leaf entry-state {
        type int32;
        description "State of ARP entry";
      }

      leaf resolution-request-count {
        type uint32;
        description
          "Number of ARP resolution request";
      }
    }  // grouping ARP-RESHIST-ENTRY

    grouping ARP-RESHIST {
      description "ARP Resolution History";
      list arp-entry {
        description
          "Resolution history array";
        uses ARP-RESHIST-ENTRY;
      }  // list arp-entry
    }  // grouping ARP-RESHIST
  }  // submodule Cisco-IOS-XR-ipv4-arp-oper-sub1