module Cisco-IOS-XR-flow-oper {

    yang-version 1;

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

    prefix flow-oper;

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

    include Cisco-IOS-XR-flow-oper-sub2 {
      revision-date "2019-04-05";
    }
    include Cisco-IOS-XR-flow-oper-sub1 {
      revision-date "2019-04-05";
    }

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

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

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

    semver:module-version "1.0.0";

    container flow {
      config false;
      description "Flow operational data";
      container nodes {
        description
          "Node table for node-specific operational data";
        list node {
          key "node-name";
          description
            "Node-specific data for a particular node";
          container flow-server {
            description
              "Flow server related";
            container exporter-map-names {
              description
                "Exporter-map related";
              list exporter-map-name {
                key "exporter-map-name";
                description
                  "Exporter-map name";
                container operational-config {
                  description
                    "Exporter-map operational configuration";
                  leaf exporter-map-name {
                    type string;
                    description
                      "Exporter-map Name";
                  }

                  leaf protocol {
                    type string;
                    description
                      "Export Protocol Name";
                  }

                  leaf destination-address {
                    type string;
                    description
                      "Destination IPv4 address in AAA.BBB.CCC.DDD
format";
                  }

                  leaf source-address {
                    type string;
                    description
                      "Source IPv4 address in AAA.BBB.CCC.DDD format";
                  }

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

                  leaf destination-port {
                    type uint16;
                    description
                      "Destination port number";
                  }

                  leaf source-port {
                    type uint16;
                    description
                      "Source port number";
                  }

                  leaf transport-protocol {
                    type string;
                    description
                      "Transport protocol";
                  }

                  leaf df-bit-set {
                    type uint8;
                    description
                      "Do Not Fragment option is set";
                  }

                  leaf dscp-value {
                    type uint8;
                    description
                      "IPv4 DSCP or IPv6 Traffic class value";
                  }

                  leaf packet-length {
                    type uint32;
                    description
                      "Maximum length of export packet excluding L2
header";
                  }

                  leaf common-template-export-timeout {
                    type uint32;
                    units "second";
                    description
                      "Common template export timeout in seconds";
                  }

                  leaf data-template-export-timeout {
                    type uint32;
                    units "second";
                    description
                      "Data template export timeout in seconds";
                  }

                  leaf options-template-export-timeout {
                    type uint32;
                    units "second";
                    description
                      "Options template export timeout in seconds";
                  }

                  leaf sampler-table-export-timeout {
                    type uint32;
                    units "second";
                    description
                      "Sampler table export timeout in seconds";
                  }

                  leaf interface-table-export-timeout {
                    type uint32;
                    units "second";
                    description
                      "Interface table export timeout in seconds";
                  }

                  leaf vrf-table-export-timeout {
                    type uint32;
                    units "second";
                    description
                      "VRF table export timeout in seconds";
                  }
                }  // container operational-config

                container operational-data {
                  description
                    "Exporter-map operational data";
                  leaf name {
                    type string;
                    description
                      "Exporter name";
                  }

                  leaf protocol {
                    type string;
                    description
                      "Export Protocol Name";
                  }

                  leaf memory-usage {
                    type uint32;
                    description
                      "Memory usage";
                  }

                  leaf-list used-by-flow-monitor {
                    type Flow-monitor-name;
                    description
                      "List of flow monitors that use the exporter";
                  }

                  list collector {
                    description
                      "Statistics of all collectors";
                    leaf exporter-state {
                      type string;
                      description
                        "Exporter state";
                    }

                    leaf destination-address {
                      type string;
                      description
                        "Destination IPv4 address in AAA.BBB.CCC.DDD
format";
                    }

                    leaf source-address {
                      type string;
                      description
                        "Source IPv4 address in AAA.BBB.CCC.DDD format";
                    }

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

                    leaf destination-port {
                      type uint16;
                      description
                        "Destination port number";
                    }

                    leaf souce-port {
                      type uint16;
                      description
                        "Source port number";
                    }

                    leaf transport-protocol {
                      type string;
                      description
                        "Transport protocol";
                    }

                    leaf packets-sent {
                      type uint64;
                      description
                        "Packets sent";
                    }

                    leaf flows-sent {
                      type uint64;
                      description
                        "Flows sent";
                    }

                    leaf templates-sent {
                      type uint64;
                      description
                        "Templates sent";
                    }

                    leaf option-templates-sent {
                      type uint64;
                      description
                        "Option templates sent";
                    }

                    leaf option-data-sent {
                      type uint64;
                      description
                        "Option data sent";
                    }

                    leaf bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Bytes sent";
                    }

                    leaf flow-bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Flow bytes sent";
                    }

                    leaf template-bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Template bytes sent";
                    }

                    leaf option-template-bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Option template bytes sent";
                    }

                    leaf option-data-bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Option data bytes sent";
                    }

                    leaf packets-dropped {
                      type uint64;
                      description
                        "Packets dropped";
                    }

                    leaf flows-dropped {
                      type uint64;
                      description
                        "Flows dropped";
                    }

                    leaf templates-dropped {
                      type uint64;
                      description
                        "Templates dropped";
                    }

                    leaf option-templates-dropped {
                      type uint64;
                      description
                        "Option templates dropped";
                    }

                    leaf option-data-dropped {
                      type uint64;
                      description
                        "Option data dropped";
                    }

                    leaf bytes-dropped {
                      type uint64;
                      units "byte";
                      description
                        "Bytes dropped";
                    }

                    leaf flow-bytes-dropped {
                      type uint64;
                      units "byte";
                      description
                        "Flow bytes dropped";
                    }

                    leaf template-bytes-dropped {
                      type uint64;
                      units "byte";
                      description
                        "Template bytes dropped";
                    }

                    leaf option-template-bytes-dropped {
                      type uint64;
                      units "byte";
                      description
                        "Option template bytes dropped";
                    }

                    leaf option-data-bytes-dropped {
                      type uint64;
                      description
                        "Option data dropped";
                    }

                    leaf last-hour-packest-sent {
                      type uint64;
                      description
                        "Total packets exported over the last one hour";
                    }

                    leaf last-hour-bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Total bytes exported over the last one hour";
                    }

                    leaf last-hour-flows-sent {
                      type uint64;
                      description
                        "Total flows exported over the of last one hour";
                    }

                    leaf last-minute-packets {
                      type uint64;
                      description
                        "Total packets exported over the last one minute";
                    }

                    leaf last-minute-bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Total bytes exported over the last one minute";
                    }

                    leaf last-minute-flows-sent {
                      type uint64;
                      description
                        "Total flows exported over the last one minute";
                    }

                    leaf last-second-packets-sent {
                      type uint64;
                      description
                        "Total packets exported over the last one second";
                    }

                    leaf last-second-bytes-sent {
                      type uint64;
                      units "byte";
                      description
                        "Total bytes exported over the last one second";
                    }

                    leaf last-second-flows-sent {
                      type uint64;
                      description
                        "Total flows exported over the last one second";
                    }
                  }  // list collector
                }  // container operational-data

                leaf exporter-map-name {
                  type xr:Cisco-ios-xr-string;
                  description
                    "The name of the exporter-map";
                }
              }  // list exporter-map-name
            }  // container exporter-map-names

            container monitor-map-names {
              description
                "Monitor-map related";
              list monitor-map-name {
                key "monitor-map-name";
                description
                  "Monitor-map name";
                container operational-config {
                  description
                    "Monitor-map operational configuration";
                  leaf fm-name {
                    type string;
                    description
                      "Name of the flow monitor";
                  }

                  leaf frec-name {
                    type string;
                    description
                      "Name of flow record";
                  }

                  leaf num-labels {
                    type uint32;
                    description
                      "Number of labels";
                  }

                  leaf aging-mode {
                    type uint32;
                    description
                      "Type of cache";
                  }

                  leaf num-entries {
                    type uint32;
                    description
                      "Total number of cache entries";
                  }

                  leaf inactive-timeout {
                    type uint32;
                    description
                      "Cache inactive timeout";
                  }

                  leaf active-timeout {
                    type uint32;
                    description
                      "Cache active timeout";
                  }

                  leaf update-timeout {
                    type uint32;
                    description
                      "Cache update timeout";
                  }

                  leaf rate-limit {
                    type uint32;
                    description
                      "Cache timeout rate-limit";
                  }

                  leaf options {
                    type uint32;
                    description
                      "flow monitor options";
                  }

                  leaf sflow-ext-router {
                    type uint8;
                    description
                      "sFlow extended router enabled";
                  }

                  leaf sflow-ext-gateway {
                    type uint8;
                    description
                      "sFlow extended gateway enabled";
                  }

                  leaf sflow-input-ifindex-physical {
                    type uint8;
                    description
                      "sFlow Using input physical interface ifindex";
                  }

                  leaf sflow-output-ifindex-physical {
                    type uint8;
                    description
                      "sFlow Using output physical interface ifindex";
                  }

                  leaf sflow-sample-header-max {
                    type uint32;
                    description
                      "sFlow Maximum size of packet header to be
exported";
                  }

                  leaf sflow-if-stats-interval {
                    type uint32;
                    description
                      "sFlow if_stats counter sampling interval";
                  }

                  list fe-name {
                    max-elements 8;
                    description
                      "Name of flow exporter";
                    leaf exist-flag {
                      type uint8;
                      description
                        "Flag where name exists or not";
                    }

                    leaf name {
                      type string;
                      description
                        "Name of flow exporter";
                    }
                  }  // list fe-name
                }  // container operational-config

                container operational-data {
                  description
                    "Monitor-map operational data";
                  container summary {
                    description
                      "Summary of the flow cache";
                    leaf cache-name {
                      type string;
                      description
                        "Cache name";
                    }

                    leaf frec-name {
                      type string;
                      description
                        "Typename of flow record";
                    }

                    leaf cache-size {
                      type uint32;
                      description
                        "Cache size";
                    }

                    leaf current-entries {
                      type uint32;
                      description
                        "Current number of entries";
                    }

                    leaf match-entries {
                      type uint32;
                      description
                        "Entries that match this search criteria";
                    }

                    leaf display-entries {
                      type uint32;
                      description
                        "Number of cache entries returned";
                    }

                    leaf high-watermark {
                      type uint32;
                      description
                        "Cache high watermark";
                    }

                    leaf fl-added {
                      type uint64;
                      description
                        "Number of flows added";
                    }

                    leaf fl-dropped {
                      type uint64;
                      description
                        "Number of flows dropped because of cache full";
                    }

                    leaf ager-polls {
                      type uint64;
                      description
                        "Total number of ager polls";
                    }

                    leaf fl-age-active-tout {
                      type uint64;
                      description
                        "Flows aged on active timeout";
                    }

                    leaf fl-age-inactive-tout {
                      type uint64;
                      description
                        "Flows aged on  inactive timeout";
                    }

                    leaf fl-age-immediate {
                      type uint64;
                      description
                        "Flows aged immediately";
                    }

                    leaf fl-age-watermark {
                      type uint64;
                      description
                        "Flows aged due to exceeding high water mark";
                    }

                    leaf fl-age-ememrgency {
                      type uint64;
                      description
                        "Flows aged due to emergency aging";
                    }

                    leaf fl-age-tcp-fin {
                      type uint64;
                      description
                        "Flows aged due to TCP FIN";
                    }

                    leaf fl-age-counter-wrap {
                      type uint64;
                      description
                        "Flows aged due to counter wrap";
                    }

                    leaf fl-tcp-fin {
                      type uint64;
                      description
                        "Flows exported with TCP FIN";
                    }

                    leaf fl-counter-wrap {
                      type uint64;
                      description
                        "Flows exported with counter wrap";
                    }

                    leaf fl-exported {
                      type uint64;
                      description
                        "Total flows given to the exporter";
                    }

                    leaf sflow-flow-samples {
                      type uint64;
                      description
                        "sFlow flow samples which came in";
                    }

                    leaf sflow-counter-samples {
                      type uint64;
                      description
                        "sFlow counter samples which came in";
                    }
                  }  // container summary

                  container internal {
                    description
                      "Internal info of the flow cache";
                    leaf cache-hits {
                      type uint64;
                      description "Hits";
                    }

                    leaf cache-misses {
                      type uint64;
                      description "Misses";
                    }

                    leaf cache-overflows {
                      type uint64;
                      description
                        "Overflows";
                    }

                    leaf cache-above-hi-water {
                      type uint64;
                      description
                        "Exceed Hi water mark";
                    }

                    leaf flows-dropped-by-ager {
                      type uint64;
                      description
                        "flows dropped by ager";
                    }

                    leaf flows-not-exported-by-clear-cache {
                      type uint64;
                      description
                        "flows not exported by clear cache";
                    }

                    leaf flows-not-aged-export-ring-full {
                      type uint64;
                      description
                        "flows not exported due to exporter ring full";
                    }

                    leaf flows-periodic-export-failure {
                      type uint64;
                      description
                        "flows not exported by updated timeout";
                    }

                    leaf cache-state {
                      type uint32;
                      description
                        "Cache state";
                    }

                    leaf total-memory {
                      type uint32;
                      description
                        "Total memory usage by this monitor";
                    }

                    leaf num-hash-buckets {
                      type uint64;
                      description
                        "Total number of hash buckets";
                    }

                    leaf max-hash-depth {
                      type uint64;
                      description
                        "Summary data";
                    }

                    list bucket-stat {
                      description
                        "Hash bucket Statistics";
                      leaf depth-min {
                        type uint16;
                        description
                          "Minimum depth";
                      }

                      leaf depth-max {
                        type uint16;
                        description
                          "Maximum depth";
                      }

                      leaf curr-depth {
                        type uint32;
                        description
                          "Buckets with current depth in range";
                      }

                      leaf max-depth {
                        type uint32;
                        description
                          "Buckets with maximum depth in range";
                      }
                    }  // list bucket-stat
                  }  // container internal
                }  // container operational-data

                leaf monitor-map-name {
                  type xr:Cisco-ios-xr-string;
                  description
                    "The name of the monitor-map";
                }
              }  // list monitor-map-name
            }  // container monitor-map-names
          }  // container flow-server

          leaf node-name {
            type xr:Node-id;
            description "Node name";
          }
        }  // list node
      }  // container nodes
    }  // container flow
  }  // module Cisco-IOS-XR-flow-oper