module Cisco-IOS-XR-ip-daps-oper {

    yang-version 1;

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

    prefix ip-daps-oper;

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

    include Cisco-IOS-XR-ip-daps-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 ip-daps package operational data.

This module contains definitions
for the following management objects:
  address-pool-service: Pool 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.1";

    container address-pool-service {
      config false;
      description "Pool operational data";
      container nodes {
        description
          "Pool operational data for a particular location";
        list node {
          key "node-name";
          description
            "Location. For eg., 0/1/CPU0";
          container pools {
            description
              "List of IPv4/IPv6 pool data";
            list pool {
              key "pool-name";
              description
                "Pool data by pool name";
              container address-ranges {
                description
                  "Summary info for pool";
                list address-range {
                  key "start-address";
                  description
                    "Start Address of the Range";
                  leaf start-address {
                    type inet:ip-address-no-zone;
                    description "IP Address";
                  }

                  container start-address-xr {
                    description
                      "Range start";
                    container address {
                      description "Address";
                      leaf address-family {
                        type Ip-addr;
                        description
                          "AddressFamily";
                      }

                      leaf ipv4-address {
                        when
                          "../address-family = 'ipv4'" {
                          description
                            "../AddressFamily = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../address-family = 'ipv6'" {
                          description
                            "../AddressFamily = 'IPv6'";
                        }
                        type Ipv6-addr;
                        description
                          "IPv6 address";
                      }
                    }  // container address
                  }  // container start-address-xr

                  container end-address {
                    description "Range end";
                    container address {
                      description "Address";
                      leaf address-family {
                        type Ip-addr;
                        description
                          "AddressFamily";
                      }

                      leaf ipv4-address {
                        when
                          "../address-family = 'ipv4'" {
                          description
                            "../AddressFamily = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../address-family = 'ipv6'" {
                          description
                            "../AddressFamily = 'IPv6'";
                        }
                        type Ipv6-addr;
                        description
                          "IPv6 address";
                      }
                    }  // container address
                  }  // container end-address

                  container default-router {
                    description
                      "Default router";
                    container address {
                      description "Address";
                      leaf address-family {
                        type Ip-addr;
                        description
                          "AddressFamily";
                      }

                      leaf ipv4-address {
                        when
                          "../address-family = 'ipv4'" {
                          description
                            "../AddressFamily = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../address-family = 'ipv6'" {
                          description
                            "../AddressFamily = 'IPv6'";
                        }
                        type Ipv6-addr;
                        description
                          "IPv6 address";
                      }
                    }  // container address
                  }  // container default-router

                  leaf pool-name {
                    type string {
                      length "0..64";
                    }
                    description "Pool name";
                  }

                  leaf vrf-name {
                    type string {
                      length "0..64";
                    }
                    description "VRF name";
                  }

                  leaf allocated-addresses {
                    type uint32;
                    description
                      "Number of addresses allocated";
                  }

                  leaf free-addresses {
                    type uint32;
                    description
                      "Number of addresses free";
                  }

                  leaf excluded-addresses {
                    type uint32;
                    description
                      "Number of addresses excluded";
                  }

                  leaf network-blocked-status {
                    type uint32;
                    description
                      "Is network blocked";
                  }

                  leaf network-blocked-status-trp {
                    type uint32;
                    description
                      "Is network blocked trap send";
                  }
                }  // list address-range
              }  // container address-ranges

              container allocated-addresses {
                description
                  "Detailed info for the Pool";
                container pool-allocations {
                  description
                    "Pool allocations";
                  container high-threshold {
                    description
                      "High threshold data";
                    leaf threshold {
                      type uint32;
                      units "percentage";
                      description
                        "Threshold in percentage";
                    }

                    leaf triggers {
                      type uint32;
                      description
                        "Number of Triggers";
                    }

                    leaf time-last-crossed {
                      type string;
                      description
                        "Last time at which threshold crossed in DDD MMM
DD HH:MM:SS YYYY format eg: Tue Apr 11 21:30:47
2011";
                    }
                  }  // container high-threshold

                  container low-threshold {
                    description
                      "Low threshold data";
                    leaf threshold {
                      type uint32;
                      units "percentage";
                      description
                        "Threshold in percentage";
                    }

                    leaf triggers {
                      type uint32;
                      description
                        "Number of Triggers";
                    }

                    leaf time-last-crossed {
                      type string;
                      description
                        "Last time at which threshold crossed in DDD MMM
DD HH:MM:SS YYYY format eg: Tue Apr 11 21:30:47
2011";
                    }
                  }  // container low-threshold

                  leaf vrf-name {
                    type string {
                      length "0..64";
                    }
                    description "VRF name";
                  }

                  leaf used {
                    type uint32;
                    description
                      "Used allocations";
                  }

                  leaf excluded {
                    type uint32;
                    description
                      "Excluded allocations";
                  }

                  leaf free {
                    type uint32;
                    description
                      "Free allocations";
                  }

                  leaf total {
                    type uint32;
                    description
                      "Total allocations";
                  }

                  leaf utilization {
                    type uint32;
                    units "percentage";
                    description
                      "Current utilization in percentage";
                  }
                }  // container pool-allocations

                list address-range {
                  description
                    "Address ranges";
                  container start-address {
                    description
                      "Range start";
                    container address {
                      description "Address";
                      leaf address-family {
                        type Ip-addr;
                        description
                          "AddressFamily";
                      }

                      leaf ipv4-address {
                        when
                          "../address-family = 'ipv4'" {
                          description
                            "../AddressFamily = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../address-family = 'ipv6'" {
                          description
                            "../AddressFamily = 'IPv6'";
                        }
                        type Ipv6-addr;
                        description
                          "IPv6 address";
                      }
                    }  // container address
                  }  // container start-address

                  container end-address {
                    description "Range end";
                    container address {
                      description "Address";
                      leaf address-family {
                        type Ip-addr;
                        description
                          "AddressFamily";
                      }

                      leaf ipv4-address {
                        when
                          "../address-family = 'ipv4'" {
                          description
                            "../AddressFamily = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../address-family = 'ipv6'" {
                          description
                            "../AddressFamily = 'IPv6'";
                        }
                        type Ipv6-addr;
                        description
                          "IPv6 address";
                      }
                    }  // container address
                  }  // container end-address

                  leaf used {
                    type uint32;
                    description
                      "Used allocations";
                  }

                  leaf excluded {
                    type uint32;
                    description
                      "Excluded allocations";
                  }

                  leaf free {
                    type uint32;
                    description
                      "Free allocations";
                  }
                }  // list address-range

                list in-use-address {
                  description
                    "In-use addresses";
                  container address {
                    description
                      "Client address";
                    container address {
                      description "Address";
                      leaf address-family {
                        type Ip-addr;
                        description
                          "AddressFamily";
                      }

                      leaf ipv4-address {
                        when
                          "../address-family = 'ipv4'" {
                          description
                            "../AddressFamily = 'IPv4'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../address-family = 'ipv6'" {
                          description
                            "../AddressFamily = 'IPv6'";
                        }
                        type Ipv6-addr;
                        description
                          "IPv6 address";
                      }
                    }  // container address
                  }  // container address

                  leaf client-type {
                    type Daps-client;
                    description
                      "Client type";
                  }
                }  // list in-use-address
              }  // container allocated-addresses

              container configuration {
                description
                  "Configuration info for pool";
                container serg-info {
                  description "SERG Info";
                  leaf preferred-role {
                    type Daps-serg-role;
                    description
                      "SERG PreferredRole";
                  }

                  leaf peer-down {
                    type boolean;
                    description "Peer Down";
                  }

                  leaf verify-pend {
                    type boolean;
                    description
                      "Verify Pending";
                  }
                }  // container serg-info

                leaf pool-name {
                  type string {
                    length "0..64";
                  }
                  description "Pool name";
                }

                leaf pool-id {
                  type uint32;
                  description
                    "Pool ID for MIBS";
                }

                leaf vrf-name {
                  type string {
                    length "0..64";
                  }
                  description "VRF name";
                }

                leaf pool-scope {
                  type string {
                    length "0..64";
                  }
                  description "Pool Scope";
                }

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

                leaf high-utilization-mark {
                  type uint8;
                  description
                    "High utilization mark";
                }

                leaf low-utilization-mark {
                  type uint8;
                  description
                    "Low utilization mark";
                }

                leaf current-utilization {
                  type uint8;
                  description
                    "Current utilization";
                }

                leaf utilization-high-count {
                  type uint32;
                  description
                    "Number of times High utilization threshold was
crossed";
                }

                leaf utilization-low-count {
                  type uint32;
                  description
                    "Number of times Low utilization threshold was
crossed";
                }
              }  // container configuration

              leaf pool-name {
                type xr:Cisco-ios-xr-string;
                description "The pool name";
              }
            }  // list pool
          }  // container pools

          container total-utilization {
            description
              "Show total utilization for pool";
            leaf total-utilization-high-mark {
              type uint8;
              description
                "High utilization mark";
            }

            leaf total-utilization-low-mark {
              type uint8;
              description
                "Low utilization mark";
            }

            leaf current-total-utilization {
              type uint8;
              description
                "Current utilization";
            }
          }  // container total-utilization

          container vrfs {
            description "Pool VRF data";
            list vrf {
              key "vrf-name";
              description
                "VRF level Pool information";
              container ipv4 {
                description
                  "IPv4 pool VRF data";
                container allocation-summary {
                  description
                    "Allocation summary";
                  leaf used {
                    type uint32;
                    description
                      "Used allocations";
                  }

                  leaf excluded {
                    type uint32;
                    description
                      "Excluded allocations";
                  }

                  leaf free {
                    type uint32;
                    description
                      "Free allocations";
                  }

                  leaf total {
                    type uint32;
                    description
                      "Total allocations";
                  }

                  leaf high-utilization-threshold {
                    type uint8;
                    units "percentage";
                    description
                      "High utilization threshold in percentage";
                  }

                  leaf low-utilization-threshold {
                    type uint8;
                    units "percentage";
                    description
                      "Low utilization threshold in percentage";
                  }

                  leaf utilization {
                    type uint8;
                    units "percentage";
                    description
                      "Current utilization in percentage";
                  }
                }  // container allocation-summary

                list pools {
                  description "Pools data";
                  leaf pool-name {
                    type string {
                      length "0..64";
                    }
                    description "Pool name";
                  }

                  leaf vrf-name {
                    type string {
                      length "0..64";
                    }
                    description "VRF name";
                  }

                  leaf used {
                    type uint32;
                    description
                      "Used allocations";
                  }

                  leaf excluded {
                    type uint32;
                    description
                      "Excluded allocations";
                  }

                  leaf free {
                    type uint32;
                    description
                      "Free allocations";
                  }

                  leaf total {
                    type uint32;
                    description
                      "Total allocations";
                  }
                }  // list pools
              }  // container ipv4

              container ipv6 {
                description
                  "IPv6 Pool VRF data";
                container allocation-summary {
                  description
                    "Allocation summary";
                  leaf used {
                    type uint32;
                    description
                      "Used allocations";
                  }

                  leaf excluded {
                    type uint32;
                    description
                      "Excluded allocations";
                  }

                  leaf free {
                    type uint32;
                    description
                      "Free allocations";
                  }

                  leaf total {
                    type uint32;
                    description
                      "Total allocations";
                  }

                  leaf high-utilization-threshold {
                    type uint8;
                    units "percentage";
                    description
                      "High utilization threshold in percentage";
                  }

                  leaf low-utilization-threshold {
                    type uint8;
                    units "percentage";
                    description
                      "Low utilization threshold in percentage";
                  }

                  leaf utilization {
                    type uint8;
                    units "percentage";
                    description
                      "Current utilization in percentage";
                  }
                }  // container allocation-summary

                list pools {
                  description "Pools data";
                  leaf pool-name {
                    type string {
                      length "0..64";
                    }
                    description "Pool name";
                  }

                  leaf vrf-name {
                    type string {
                      length "0..64";
                    }
                    description "VRF name";
                  }

                  leaf used {
                    type uint32;
                    description
                      "Used allocations";
                  }

                  leaf excluded {
                    type uint32;
                    description
                      "Excluded allocations";
                  }

                  leaf free {
                    type uint32;
                    description
                      "Free allocations";
                  }

                  leaf total {
                    type uint32;
                    description
                      "Total allocations";
                  }
                }  // list pools
              }  // container ipv6

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

          leaf node-name {
            type xr:Node-id;
            description "Node name";
          }
        }  // list node
      }  // container nodes
    }  // container address-pool-service
  }  // module Cisco-IOS-XR-ip-daps-oper