module Cisco-IOS-XR-infra-policymgr-oper {

    yang-version 1;

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

    prefix infra-policymgr-oper;

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

    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 infra-policymgr package operational data.
     
     This module contains definitions
     for the following management objects:
       policy-manager: Policy-map operational data
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-09-24" {
      description "IOS XR 7.3.1 revision.";
    }

    revision "2020-05-19" {
      description "IOS XR 7.3.1 revision.";
    }

    revision "2020-04-29" {
      description "IOS XR 7.3.1 revision.";
    }

    revision "2019-10-29" {
      description "IOS XR 7.2.1 revision.";
    }

    revision "2019-09-11" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2019-09-09" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2019-09-05" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2019-08-31" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2019-08-16" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2019-08-12" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2019-07-30" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2019-05-27" {
      description "IOS XR 7.0.1 revision.";
    }

    revision "2019-03-27" {
      description "IOS XR 7.0.1 revision.";
    }

    revision "2019-02-28" {
      description "IOS XR 7.0.1 revision.";
    }

    revision "2018-09-20" {
      description "IOS XR 7.1.1 revision.";
    }

    revision "2018-01-17" {
      description "IOS XR 6.4.1 revision.";
    }

    revision "2017-05-27" {
      description "IOS XR 6.3.1 revision.";
    }

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


    typedef afi-enum {
      type enumeration {
        enum "ipv4" {
          value 1;
          description "Address family IPv4";
        }
        enum "ipv6" {
          value 2;
          description "Address family IPv6";
        }
      }
    }

    typedef Policymgr-policy-map {
      type enumeration {
        enum "qos" {
          value 1;
          description "QoS Policymap";
        }
        enum "pbr" {
          value 2;
          description "PBR Policymap";
        }
        enum "traffic" {
          value 3;
          description "TRAFFIC Policymap";
        }
        enum "subscriber-control" {
          value 4;
          description
            "SUBSCONTROL Policymap";
        }
        enum "accounting" {
          value 5;
          description "ACCOUNTING Policymap";
        }
        enum "redirect" {
          value 6;
          description "REDIRECT Policy map";
        }
        enum "flow-monitor" {
          value 7;
          description
            "FlOWMONITOR Policy map";
        }
      }
      description "Policymgr policy map";
    }

    typedef Policymgr-class-map {
      type enumeration {
        enum "qos" {
          value 1;
          description "QoS Classmap";
        }
        enum "pbr" {
          value 2;
          description "PBR Classmap";
        }
        enum "traffic" {
          value 3;
          description "TRAFFIC Classmap";
        }
        enum "subscriber-control" {
          value 4;
          description "SUBSCONTROL Classmap";
        }
      }
      description "Policymgr class map";
    }

    typedef Pclass-exec-strat-en {
      type enumeration {
        enum "pclass-exe-strat-unspecified" {
          value 0;
          description "Unspecified";
        }
        enum "pclass-exe-strat-do-all" {
          value 1;
          description "Exec all actions";
        }
        enum
          "pclass-exe-strat-do-until-success" {
          value 2;
          description
            "Exec until one of actions succeeds";
        }
        enum
          "pclass-exe-strat-do-until-failure" {
          value 3;
          description
            "Exec until there is a failure";
        }
        enum "pclass-exe-strat-max" {
          value 4;
          description "Invalid";
        }
      }
      description
        "Policy class execution strategy";
    }

    typedef Match-available-id-en {
      type enumeration {
        enum "match-avail-ident-unspecified" {
          value 0;
          description
            "match avail ident unspecified";
        }
        enum "match-avail-ident-dnis" {
          value 1;
          description
            "match avail ident dnis";
        }
        enum "match-avail-ident-domain" {
          value 2;
          description
            "match avail ident domain";
        }
        enum "match-avail-ident-circuit-id" {
          value 3;
          description
            "match avail ident circuit id";
        }
        enum "match-avail-ident-remote-id" {
          value 4;
          description
            "match avail ident remote id";
        }
        enum "match-avail-ident-media" {
          value 5;
          description
            "match avail ident media";
        }
        enum "match-avail-ident-nas-port" {
          value 6;
          description
            "match avail ident nas port";
        }
        enum "match-avail-ident-protocol" {
          value 7;
          description
            "match avail ident protocol";
        }
        enum
          "match-avail-ident-source-address-ipv4" {
          value 8;
          description
            "match avail ident source address ipv4";
        }
        enum
          "match-avail-ident-source-address-ipv6" {
          value 9;
          description
            "match avail ident source address ipv6";
        }
        enum
          "match-avail-ident-source-address-mac" {
          value 10;
          description
            "match avail ident source address mac";
        }
        enum "match-avail-ident-tunnel-name" {
          value 11;
          description
            "match avail ident tunnel name";
        }
        enum "match-avail-ident-user-name" {
          value 12;
          description
            "match avail ident user name";
        }
        enum "match-avail-ident-vendor-id" {
          value 13;
          description
            "match avail ident vendor id";
        }
        enum
          "match-avail-ident-dhcp-client-id" {
          value 14;
          description
            "match avail ident dhcp client id";
        }
        enum "match-avail-ident-max" {
          value 15;
          description
            "match avail ident max";
        }
      }
      description "Match available id en";
    }

    typedef Afmon-alarm-type-en {
      type enumeration {
        enum "afmon-alm-type-invalid" {
          value 0;
          description
            "afmon alm type invalid";
        }
        enum "afmon-alm-discrete" {
          value 1;
          description "afmon alm discrete";
        }
        enum "afmon-alm-grp-cnt" {
          value 2;
          description "afmon alm grp cnt";
        }
        enum "afmon-alm-grp-pct" {
          value 3;
          description "afmon alm grp pct";
        }
        enum "afmon-alm-type-max" {
          value 4;
          description "afmon alm type max";
        }
      }
      description "Afmon alarm type en";
    }

    typedef Decode-identifier-en {
      type enumeration {
        enum "policy-decid-unspecified" {
          value 0;
          description
            "policy decid unspecified";
        }
        enum "policy-decid-remote-id" {
          value 1;
          description
            "policy decid remote id";
        }
        enum "policy-decid-circuit-id" {
          value 2;
          description
            "policy decid circuit id";
        }
        enum "policy-decid-user-name" {
          value 3;
          description
            "policy decid user name";
        }
        enum "policy-decid-max" {
          value 4;
          description "policy decid max";
        }
      }
      description "Decode identifier en";
    }

    typedef Class-map-name {
      type string {
        length "0..65";
      }
      description "Class map name";
    }

    typedef Policy-chk-sum {
      type string {
        length "0..16";
      }
      description "Policy chk sum";
    }

    typedef Policy-action-en {
      type enumeration {
        enum "policy-action-none" {
          value 0;
          description "Policy Action None";
        }
        enum "policy-action-unspecified" {
          value 1;
          description
            "Policy Action is not specified";
        }
        enum "policy-action-mark" {
          value 2;
          description "Policy Action Mark";
        }
        enum "policy-action-mark2" {
          value 3;
          description "Policy Action Mark2";
        }
        enum "policy-action-wred" {
          value 4;
          description "Policy Action WRED";
        }
        enum "policy-action-encap-seq" {
          value 5;
          description
            "Policy action encap-sequence number";
        }
        enum "policy-action-priority" {
          value 6;
          description
            "Policy Action Priority Queue";
        }
        enum "policy-action-iphc" {
          value 7;
          description
            "Policy Action IP Header Compression";
        }
        enum "policy-action-bw-remaining" {
          value 8;
          description
            "Policy Action Bandwidth Remaining Queue";
        }
        enum "policy-action-min-bw" {
          value 9;
          description
            "Policy Action Minimum Bandwidth Queue";
        }
        enum
          "policy-action-authenticate-aaa" {
          value 10;
          description
            "Policy Action authenticate";
        }
        enum "policy-action-collect-id" {
          value 11;
          description
            "Policy Action collect identifier";
        }
        enum "policy-action-disconnect" {
          value 12;
          description
            "Policy Action disconnect session";
        }
        enum "policy-action-set-timer" {
          value 13;
          description
            "Policy Action set timer";
        }
        enum "policy-action-stop-timer" {
          value 14;
          description
            "Policy Action stop timer";
        }
        enum "policy-action-query-ancp" {
          value 15;
          description
            "Policy Action query ancp";
        }
        enum
          "policy-action-accounting-aaa-list" {
          value 16;
          description
            "Policy Action accounting aaa";
        }
        enum "policy-action-prepaid-config" {
          value 17;
          description
            "Policy Action prepaid config";
        }
        enum "policy-action-timeout-idle" {
          value 18;
          description
            "Policy Action timeout idle";
        }
        enum "policy-action-proxy-aaa" {
          value 19;
          description
            "Policy Action proxy aaa";
        }
        enum
          "policy-action-template-activate" {
          value 20;
          description
            "Policy Action activate template";
        }
        enum
          "policy-action-template-deactivate" {
          value 21;
          description
            "Policy Action deactivate template";
        }
        enum
          "policy-action-decode-identifier" {
          value 22;
          description
            "Policy Action decode identifier";
        }
        enum "policy-action-q-limit" {
          value 23;
          description
            "Policy Action Queue Limit";
        }
        enum "policy-action-authorize-id" {
          value 24;
          description
            "Policy Action authorize idetifier";
        }
        enum
          "policy-action-accounting-event-aaa-list" {
          value 25;
          description
            "Policy Action accounting event";
        }
        enum "policy-action-afmon-react" {
          value 26;
          description
            "Policy Action React (afmon)";
        }
        enum "policy-action-httpr" {
          value 27;
          description
            "Policy Action httpr (pbr)";
        }
        enum "policy-action-pbr-transmit" {
          value 28;
          description
            "Policy Action pbr transmit";
        }
        enum "policy-action-pbr-drop" {
          value 29;
          description
            "Policy Action pbr drop";
        }
        enum "policy-action-punt" {
          value 30;
          description
            "Policy Action pbr punt";
        }
        enum "policy-action-copy" {
          value 31;
          description
            "Policy Action pbr copy";
        }
        enum "policy-action-sfrag" {
          value 32;
          description
            "Policy Action Service fragment";
        }
        enum "policy-action-monitor" {
          value 33;
          description
            "Policy Action Monitor";
        }
        enum "policy-action-redirect" {
          value 34;
          description
            "Policy Action redirect";
        }
        enum "policy-action-ipv4-nh" {
          value 35;
          description
            "Policy Action ipv4 next hop";
        }
        enum "policy-action-ipv6-nh" {
          value 36;
          description
            "Policy Action ipv6 next hop";
        }
        enum "policy-action-vlan-pop" {
          value 37;
          description "Policy Action pop";
        }
        enum "policy-action-pbr-next-hop" {
          value 38;
          description
            "Policy Action PBR Forward";
        }
        enum "policy-action-decap-gre" {
          value 39;
          description
            "Policy Action decapsule GRE";
        }
        enum
          "policy-action-output-interface" {
          value 40;
          description
            "Policy Action PBR redirect interface";
        }
        enum
          "policy-action-service-function-path" {
          value 41;
          description
            "Policy Action PBR service chaining";
        }
        enum "policy-action-http-enrich" {
          value 42;
          description
            "Policy Action FTTP Enrich";
        }
        enum "policy-action-decap-gue-v1" {
          value 43;
          description
            "Policy Action decapsule GUE v1";
        }
        enum "policy-action-ptrs" {
          value 44;
          description
            "Dummy action for internal use";
        }
        enum "policy-action-police" {
          value 45;
          description "Policy Action Police";
        }
        enum "policy-action-shape" {
          value 46;
          description "Policy Action Shape";
        }
        enum "policy-action-serv-pol" {
          value 47;
          description
            "Policy Action Service Policy";
        }
        enum "policy-action-cac" {
          value 48;
          description "Policy Action CAC";
        }
        enum "policy-action-afmon-flow-parm" {
          value 49;
          description
            "Policy Action Flow params (afmon)";
        }
        enum
          "policy-action-afmon-ipcbr-metric" {
          value 50;
          description
            "Policy Action IP-CBR Metric (afmon)";
        }
        enum
          "policy-action-afmon-rtp-metric" {
          value 51;
          description
            "Policy Action RTP-Custom Metric (afmon)";
        }
        enum
          "policy-action-afmon-rtp-mmr-metric" {
          value 52;
          description
            "Policy Action RTP-MMR Metric (afmon)";
        }
        enum
          "policy-action-afmon-rtp-j2k-metric" {
          value 53;
          description
            "Policy Action RTP-J2K Metric (afmon)";
        }
        enum
          "policy-action-afmon-rtp-voice-metric" {
          value 54;
          description
            "Policy Action RTP-Voice Metric (afmon)";
        }
        enum
          "policy-action-afmon-mdi-metric" {
          value 55;
          description
            "Policy Action MDI Metric (afmon)";
        }
        enum
          "policy-action-afmon-mdi-rtp-metric" {
          value 56;
          description
            "Policy Action MDI RTP Metric (afmon)";
        }
        enum "policy-action-afmon-fmm" {
          value 57;
          description
            "Policy Action flow monitor (afmon)";
        }
        enum "policy-action-pfc" {
          value 58;
          description "Policy Action PFC";
        }
        enum "policy-action-max" {
          value 59;
          description
            "Policy Action Max (Invalid)";
        }
      }
      description
        "Policy Actions Enumeration";
    }

    typedef Cac-flow-actn-type-e {
      type uint8;
      description "Cac flow actn type e";
    }

    typedef Authorize-id-en {
      type enumeration {
        enum
          "policy-authorize-ident-unspecified" {
          value 0;
          description
            "policy authorize ident unspecified";
        }
        enum "policy-authorize-ident-dnis" {
          value 1;
          description
            "policy authorize ident dnis";
        }
        enum "policy-authorize-ident-domain" {
          value 2;
          description
            "policy authorize ident domain";
        }
        enum
          "policy-authorize-ident-user-name" {
          value 3;
          description
            "policy authorize ident user name";
        }
        enum
          "policy-authorize-ident-nas-port" {
          value 4;
          description
            "policy authorize ident nas port";
        }
        enum
          "policy-authorize-ident-source-address-ipv4" {
          value 5;
          description
            "policy authorize ident source address ipv4";
        }
        enum
          "policy-authorize-ident-source-address-ipv6" {
          value 6;
          description
            "policy authorize ident source address ipv6";
        }
        enum
          "policy-authorize-ident-source-address-mac" {
          value 7;
          description
            "policy authorize ident source address mac";
        }
        enum
          "policy-authorize-ident-auto-detect" {
          value 8;
          description
            "policy authorize ident auto detect";
        }
        enum
          "policy-authorize-ident-tunnel-name" {
          value 9;
          description
            "policy authorize ident tunnel name";
        }
        enum
          "policy-authorize-ident-dhcp-client-id" {
          value 10;
          description
            "policy authorize ident dhcp client id";
        }
        enum
          "policy-authorize-ident-circuit-id" {
          value 11;
          description
            "policy authorize ident circuit id";
        }
        enum
          "policy-authorize-ident-remote-id" {
          value 12;
          description
            "policy authorize ident remote id";
        }
        enum
          "policy-authorize-ident-vendor-id" {
          value 13;
          description
            "policy authorize ident vendor id";
        }
        enum
          "policy-authorize-ident-service-name" {
          value 14;
          description
            "policy authorize ident service name";
        }
        enum "policy-authorize-ident-max" {
          value 15;
          description
            "policy authorize ident max";
        }
      }
      description "Authorize id en";
    }

    typedef Afmon-ipcbr-parm-type-en {
      type enumeration {
        enum "afmon-ipcbr-parm-invalid" {
          value 0;
          description
            "afmon ipcbr parm invalid";
        }
        enum "afmon-ipcbr-parm-ip-pkt-rate" {
          value 1;
          description
            "afmon ipcbr parm ip pkt rate";
        }
        enum "afmon-ipcbr-parm-ip-bit-rate" {
          value 2;
          description
            "afmon ipcbr parm ip bit rate";
        }
        enum
          "afmon-ipcbr-parm-media-bit-rate" {
          value 3;
          description
            "afmon ipcbr parm media bit rate";
        }
        enum
          "afmon-ipcbr-parm-media-pkt-size" {
          value 4;
          description
            "afmon ipcbr parm media pkt size";
        }
        enum
          "afmon-ipcbr-parm-media-pkts-per-ip" {
          value 5;
          description
            "afmon ipcbr parm media pkts per ip";
        }
        enum "afmon-ipcbr-parm-max" {
          value 6;
          description "afmon ipcbr parm max";
        }
      }
      description "Afmon ipcbr parm type en";
    }

    typedef Match-media-type-en {
      type enumeration {
        enum "match-media-type-unspecified" {
          value 0;
          description
            "match media type unspecified";
        }
        enum "match-media-type-async" {
          value 1;
          description
            "match media type async";
        }
        enum "match-media-type-atm" {
          value 2;
          description "match media type atm";
        }
        enum "match-media-type-ether" {
          value 3;
          description
            "match media type ether";
        }
        enum "match-media-type-ip" {
          value 4;
          description "match media type ip";
        }
        enum "match-media-type-isdn" {
          value 5;
          description
            "match media type isdn";
        }
        enum "match-media-type-mpls" {
          value 6;
          description
            "match media type mpls";
        }
        enum "match-media-type-sync" {
          value 7;
          description
            "match media type sync";
        }
        enum "match-media-type-max" {
          value 8;
          description "match media type max";
        }
      }
      description "Match media type en";
    }

    typedef Plmgr-appln-type-en {
      type enumeration {
        enum "qos" {
          value 1;
          description "Application type QOS";
        }
        enum "pbr" {
          value 2;
          description "Application type PBR";
        }
        enum "subscriber-control" {
          value 3;
          description
            "Application type subscriber control";
        }
        enum "accounting" {
          value 4;
          description
            "Application type accounting";
        }
        enum "traffic" {
          value 5;
          description
            "Application type traffic";
        }
        enum "performance-traffic" {
          value 6;
          description
            "Application type performance traffic";
        }
      }
      description
        "Different Application types";
    }

    typedef Policy-route-target-en {
      type enumeration {
        enum "policy-rt-type-none" {
          value 0;
          description "policy rt type none";
        }
        enum "policy-rt-type-asn2" {
          value 1;
          description "policy rt type asn2";
        }
        enum "policy-rt-type-ipv4" {
          value 2;
          description "policy rt type ipv4";
        }
        enum "policy-rt-type-asn4" {
          value 3;
          description "policy rt type asn4";
        }
        enum "policy-rt-type-max" {
          value 4;
          description "policy rt type max";
        }
      }
      description "Policy route target en";
    }

    typedef Identifier-en {
      type enumeration {
        enum "policy-ident-unspecified" {
          value 0;
          description
            "policy ident unspecified";
        }
        enum "policy-ident-authen-status" {
          value 1;
          description
            "policy ident authen status";
        }
        enum "policy-ident-dnis" {
          value 2;
          description "policy ident dnis";
        }
        enum "policy-ident-media" {
          value 3;
          description "policy ident media";
        }
        enum "policy-ident-mlp-negotiated" {
          value 4;
          description
            "policy ident mlp negotiated";
        }
        enum "policy-ident-nas-port" {
          value 5;
          description
            "policy ident nas port";
        }
        enum "policy-ident-no-user-name" {
          value 6;
          description
            "policy ident no user name";
        }
        enum "policy-ident-protocol" {
          value 7;
          description
            "policy ident protocol";
        }
        enum "policy-ident-service-name" {
          value 8;
          description
            "policy ident service name";
        }
        enum
          "policy-ident-source-address-ipv4" {
          value 9;
          description
            "policy ident source address ipv4";
        }
        enum
          "policy-ident-source-address-ipv6" {
          value 10;
          description
            "policy ident source address ipv6";
        }
        enum
          "policy-ident-source-address-mac" {
          value 11;
          description
            "policy ident source address mac";
        }
        enum "policy-ident-timer" {
          value 12;
          description "policy ident timer";
        }
        enum "policy-ident-tunnel-name" {
          value 13;
          description
            "policy ident tunnel name";
        }
        enum "policy-ident-auth-domain" {
          value 14;
          description
            "policy ident auth domain";
        }
        enum "policy-ident-auth-user-name" {
          value 15;
          description
            "policy ident auth user name";
        }
        enum "policy-ident-unauth-domain" {
          value 16;
          description
            "policy ident unauth domain";
        }
        enum "policy-ident-unauth-user-name" {
          value 17;
          description
            "policy ident unauth user name";
        }
        enum "policy-ident-max" {
          value 18;
          description "policy ident max";
        }
      }
      description "Identifier en";
    }

    typedef Mark-type-en {
      type enumeration {
        enum "mark-type-none" {
          value 0;
          description "Mark None";
        }
        enum "mark-type-dscp" {
          value 1;
          description "Mark DSCP";
        }
        enum "mark-type-prec" {
          value 2;
          description "Mark Precedence";
        }
        enum "mark-type-mpls-exp-topmost" {
          value 3;
          description
            "Mark MPLS EXP on topmost header";
        }
        enum "mark-type-mpls-exp-imposition" {
          value 4;
          description
            "Mark MPLS EXP on imposition header";
        }
        enum "mark-type-qos-group" {
          value 5;
          description "Mark QoS Group";
        }
        enum "mark-type-discard-class" {
          value 6;
          description "Mark Discard Class";
        }
        enum "mark-type-cos" {
          value 7;
          description "Mark CoS";
        }
        enum "mark-type-cos-inner" {
          value 8;
          description "Mark COS Inner";
        }
        enum "mark-type-srp-priority" {
          value 9;
          description "Mark Priority";
        }
        enum "mark-type-atm-clp" {
          value 10;
          description "Mark ATM CLP";
        }
        enum "mark-type-fr-de" {
          value 11;
          description "Mark FR DE";
        }
        enum "mark-type-dscp-tunnel" {
          value 12;
          description
            "Mark DSCP in Tunnel Header";
        }
        enum "mark-type-prec-tunnel" {
          value 13;
          description
            "Mark Precedence in Tunnel Header";
        }
        enum "mark-type-dei" {
          value 14;
          description "Mark DEI";
        }
        enum "mark-type-dei-imposition" {
          value 15;
          description
            "Mark DEI on imposition header";
        }
        enum "mark-type-forward-class" {
          value 16;
          description "Mark forward class";
        }
        enum "mark-type-df" {
          value 17;
          description "Mark DF bit";
        }
        enum "mark-type-traffic-class" {
          value 18;
          description "Mark Traffic Class";
        }
        enum "mark-type-src-mac" {
          value 19;
          description "Mark source mac";
        }
        enum "mark-type-dst-mac" {
          value 20;
          description "Mark destination mac";
        }
        enum "mark-type-ipv4-src-addr" {
          value 21;
          description
            "Mark ipv4 source address";
        }
        enum "mark-type-ipv4-dst-addr" {
          value 22;
          description
            "Mark ipv4 destination address";
        }
        enum "mark-type-vlan-id" {
          value 23;
          description "Mark vlan id";
        }
        enum "mark-type-udp-src-port" {
          value 24;
          description
            "Mark type udp source port";
        }
        enum "mark-type-udp-dst-port" {
          value 25;
          description
            "Mark type udp destination port";
        }
        enum "mark-type-tcp-src-port" {
          value 26;
          description
            "Mark type tcp source port";
        }
        enum "mark-type-tcp-dst-port" {
          value 27;
          description
            "Mark type tcp destination port";
        }
        enum "mark-type-sctp-src-port" {
          value 28;
          description
            "Mark type sctp source port";
        }
        enum "mark-type-sctp-dst-port" {
          value 29;
          description
            "Mark type sctp destination port";
        }
        enum "mark-type-max" {
          value 30;
          description
            "Mark Type Max (Invalid)";
        }
      }
      description "Mark Type Enumeration";
    }

    typedef Qlimit-type-en {
      type enumeration {
        enum "qlimit-cmd" {
          value 0;
          description "Queue Limit";
        }
        enum "qlimit-discard-class" {
          value 1;
          description
            "Queue Limit based on Discard Class";
        }
        enum "qlimit-qos-group" {
          value 2;
          description
            "Queue Limit based on Qos Group";
        }
        enum "qlimit-precedence" {
          value 3;
          description
            "Queue Limit based on Precedence";
        }
        enum "qlimit-mpls-exp" {
          value 4;
          description
            "Queue Limit based on Mpls Exp";
        }
        enum "qlimit-dscp" {
          value 5;
          description
            "Queue Limit based on Dscp";
        }
        enum "qlimit-max" {
          value 6;
          description
            "Queue Limit Max (Invalid)";
        }
      }
      description "Queue Limit Types";
    }

    typedef Afmon-react-criterion-en {
      type enumeration {
        enum "afmon-react-crit-invalid" {
          value 0;
          description
            "afmon react crit invalid";
        }
        enum "afmon-react-mrv" {
          value 1;
          description "afmon react mrv";
        }
        enum "afmon-react-df" {
          value 2;
          description "afmon react df";
        }
        enum "afmon-react-mse" {
          value 3;
          description "afmon react mse";
        }
        enum "afmon-react-pkt-rate" {
          value 4;
          description "afmon react pkt rate";
        }
        enum "afmon-react-flow-cnt" {
          value 5;
          description "afmon react flow cnt";
        }
        enum "afmon-react-rtp-loss-fraction" {
          value 6;
          description
            "afmon react rtp loss fraction";
        }
        enum "afmon-react-rtp-jitter" {
          value 7;
          description
            "afmon react rtp jitter";
        }
        enum "afmon-react-rtp-max-jitter" {
          value 8;
          description
            "afmon react rtp max jitter";
        }
        enum "afmon-react-rtp-out-of-order" {
          value 9;
          description
            "afmon react rtp out of order";
        }
        enum "afmon-react-rtp-loss-pkts" {
          value 10;
          description
            "afmon react rtp loss pkts";
        }
        enum "afmon-react-rtp-ta" {
          value 11;
          description "afmon react rtp ta";
        }
        enum "afmon-react-rtp-es" {
          value 12;
          description "afmon react rtp es";
        }
        enum "afmon-react-mdi-mlr" {
          value 13;
          description "afmon react mdi mlr";
        }
        enum "afmon-react-mdi-mdc" {
          value 14;
          description "afmon react mdi mdc";
        }
        enum "afmon-react-mdi-jitter" {
          value 15;
          description
            "afmon react mdi jitter";
        }
        enum "afmon-react-mdi-loss-pkts" {
          value 16;
          description
            "afmon react mdi loss pkts";
        }
        enum "afmon-react-mdi-ta" {
          value 17;
          description "afmon react mdi ta";
        }
        enum "afmon-react-mdi-es" {
          value 18;
          description "afmon react mdi es";
        }
        enum "afmon-react-crit-max" {
          value 19;
          description "afmon react crit max";
        }
      }
      description "Afmon react criterion en";
    }

    typedef Pfc-pause-type {
      type enumeration {
        enum "pfc-buffer-size-defined" {
          value 0;
          description
            "pfc buffer size defined";
        }
        enum "pfc-pause-threshold-defined" {
          value 1;
          description
            "pfc pause threshold defined";
        }
        enum "pfc-resume-threshold-defined" {
          value 2;
          description
            "pfc resume threshold defined";
        }
        enum "pfc-buffer-size-value" {
          value 3;
          description
            "pfc buffer size value";
        }
        enum "pfc-pause-threshold-value" {
          value 4;
          description
            "pfc pause threshold value";
        }
        enum "pfc-resume-threshold-value" {
          value 5;
          description
            "pfc resume threshold value";
        }
      }
      description "Pfc pause type";
    }

    typedef Police-actn-category-en {
      type enumeration {
        enum "police-actn-category-conform" {
          value 0;
          description "Conform action";
        }
        enum "police-actn-category-exceed" {
          value 1;
          description "Exceed action";
        }
        enum "police-actn-category-violate" {
          value 2;
          description "Violate action";
        }
        enum "police-actn-category-max" {
          value 3;
          description
            "Maximum police action categories";
        }
      }
      description "Police Action Categories";
    }

    typedef Redirect-type-e {
      type uint8;
      description "Redirect type e";
    }

    typedef Match-nas-port-sub-id-en {
      type enumeration {
        enum
          "match-nas-port-sub-id-unspecified" {
          value 0;
          description
            "match nas port sub id unspecified";
        }
        enum "match-nas-port-sub-id-adapter" {
          value 1;
          description
            "match nas port sub id adapter";
        }
        enum "match-nas-port-sub-id-channel" {
          value 2;
          description
            "match nas port sub id channel";
        }
        enum "match-nas-port-sub-id-ip-addr" {
          value 3;
          description
            "match nas port sub id ip addr";
        }
        enum "match-nas-port-sub-id-port" {
          value 4;
          description
            "match nas port sub id port";
        }
        enum "match-nas-port-sub-id-shelf" {
          value 5;
          description
            "match nas port sub id shelf";
        }
        enum "match-nas-port-sub-id-slot" {
          value 6;
          description
            "match nas port sub id slot";
        }
        enum
          "match-nas-port-sub-id-sub-interface" {
          value 7;
          description
            "match nas port sub id sub interface";
        }
        enum "match-nas-port-sub-id-type" {
          value 8;
          description
            "match nas port sub id type";
        }
        enum "match-nas-port-sub-id-vci" {
          value 9;
          description
            "match nas port sub id vci";
        }
        enum "match-nas-port-sub-id-vlan" {
          value 10;
          description
            "match nas port sub id vlan";
        }
        enum "match-nas-port-sub-id-vpi" {
          value 11;
          description
            "match nas port sub id vpi";
        }
        enum "match-nas-port-sub-id-max" {
          value 12;
          description
            "match nas port sub id max";
        }
      }
      description "Match nas port sub id en";
    }

    typedef Mark-type-e {
      type uint8;
      description "Mark type e";
    }

    typedef Object-name {
      type string {
        length "0..65";
      }
      description "Object name";
    }

    typedef Cac-flow-actn-type-en {
      type enumeration {
        enum "cac-flow-actn-type-local" {
          value 0;
          description "CAC flow local";
        }
        enum "cac-flow-actn-type-max" {
          value 1;
          description "Max CAC flow types";
        }
      }
      description "CAC flow types";
    }

    typedef Policy-map-table-type-e {
      type uint8;
      description "Policy map table type e";
    }

    typedef Enum-val-t {
      type uint16;
      description "Enum val t";
    }

    typedef Afmon-react-actn-en {
      type enumeration {
        enum "afmon-react-actn-none" {
          value 0;
          description
            "afmon react actn none";
        }
        enum "afmon-react-syslog" {
          value 1;
          description "afmon react syslog";
        }
        enum "afmon-react-snmp" {
          value 2;
          description "afmon react snmp";
        }
        enum "afmon-react-clone" {
          value 3;
          description "afmon react clone";
        }
      }
      description "Afmon react actn en";
    }

    typedef Pevent-cond-eval-en {
      type enumeration {
        enum "pevent-cond-eval-unspecified" {
          value 0;
          description
            "Unspecified execution strategy";
        }
        enum "pevent-cond-eval-match-first" {
          value 1;
          description
            "Match-first execution strategy";
        }
        enum "pevent-cond-eval-match-all" {
          value 2;
          description
            "Match-all execution strategy";
        }
        enum "pevent-cond-eval-max" {
          value 3;
          description "Internal use only";
        }
      }
      description
        "Policy event execution strategy enumeration";
    }

    typedef Dpss-snid-type-en {
      type enumeration {
        enum "dpss-snid-invalid" {
          value 0;
          description "dpss snid invalid";
        }
        enum "dpss-snid-index" {
          value 1;
          description "dpss snid index";
        }
        enum "dpss-snid-name" {
          value 2;
          description "dpss snid name";
        }
        enum "dpss-snid-type-max" {
          value 3;
          description "dpss snid type max";
        }
      }
      description "Dpss snid type en";
    }

    typedef Pclass-data-avl-inbag {
      type uint64;
      description "Pclass data avl inbag";
    }

    typedef Match-type-en {
      type enumeration {
        enum "match-type-none" {
          value 0;
          description "Match Type None";
        }
        enum "match-type-ipv4-dscp" {
          value 1;
          description "Match Type IPv4 DSCP";
        }
        enum "match-type-ipv4-prec" {
          value 2;
          description
            "Match Type IPv4 Precedence";
        }
        enum "match-type-ipv6-dscp" {
          value 3;
          description "Match Type IPv6 DSCP";
        }
        enum "match-type-packet-length" {
          value 4;
          description
            "Match Type Packet length";
        }
        enum "match-type-ipv4-packet-length" {
          value 5;
          description
            "Match Type IPv4 Packet length";
        }
        enum "match-type-ipv6-packet-length" {
          value 6;
          description
            "Match Type IPv6 Packet length";
        }
        enum "match-type-flow-tag" {
          value 7;
          description "Match Type Flow Tag";
        }
        enum "match-type-icmpv4-type" {
          value 8;
          description
            "Match Type IPv4 icmp-type";
        }
        enum "match-type-icmpv4-code" {
          value 9;
          description
            "Match Type IPv4 icmp-code";
        }
        enum "match-type-icmpv6-type" {
          value 10;
          description
            "Match Type IPv6 icmp-type";
        }
        enum "match-type-icmpv6-code" {
          value 11;
          description
            "Match Type IPv6 icmp-code";
        }
        enum "match-type-ipv6-prec" {
          value 12;
          description
            "Match Type IPv6 Precedence";
        }
        enum "match-type-fragment-type" {
          value 13;
          description
            "Match type fragment-type";
        }
        enum "match-type-tcp-flag" {
          value 14;
          description "Match type TCP flag";
        }
        enum "match-type-dscp" {
          value 15;
          description "Match Type DSCP";
        }
        enum "match-type-prec" {
          value 16;
          description
            "Match Type Precedence";
        }
        enum "match-type-proto" {
          value 17;
          description "Match Type Protocol";
        }
        enum "match-type-proto-icmpv4" {
          value 18;
          description
            "Match Type protocol ICMPv4";
        }
        enum "match-type-proto-icmpv6" {
          value 19;
          description
            "Match Type protocol ICMPv6";
        }
        enum "match-type-mpls-exp-top" {
          value 20;
          description
            "Match Type MPLS EXP Topmost";
        }
        enum "match-type-mpls-exp-imp" {
          value 21;
          description
            "Match Type MPLS EXP Imposition";
        }
        enum "match-type-mpls-disp-ipv4-acl" {
          value 22;
          description
            "Match Type MPLS DISP IPv4 ACL";
        }
        enum "match-type-mpls-disp-ipv6-acl" {
          value 23;
          description
            "Match Type MPLS DISP IPv6 ACL";
        }
        enum "match-type-mpls-disp-cl-map" {
          value 24;
          description
            "Match Type MPLS DISP Class Map";
        }
        enum "match-type-mpls-topmost-eos" {
          value 25;
          description
            "Match Type MPLS TOPMOST EOS";
        }
        enum "match-type-mpls-topmost-label" {
          value 26;
          description
            "Match Type MPLS TOPMOST LABEL";
        }
        enum "match-type-cos" {
          value 27;
          description "Match Type COS";
        }
        enum "match-type-cos-inner" {
          value 28;
          description "Match Type inner COS";
        }
        enum "match-type-dei" {
          value 29;
          description "Match Type DEI";
        }
        enum "match-type-dei-inner" {
          value 30;
          description "Match Type inner DEI";
        }
        enum "match-type-vlan" {
          value 31;
          description "Match Type VLAN";
        }
        enum "match-type-vlan-inner" {
          value 32;
          description
            "Match Type inner VLAN";
        }
        enum "match-type-fr-dlci" {
          value 33;
          description "Match Type  FR DLCI";
        }
        enum "match-type-src-mac" {
          value 34;
          description
            "Match Type Source MAC Address";
        }
        enum "match-type-dst-mac" {
          value 35;
          description
            "Match Type Destination MAC Address";
        }
        enum "match-type-atm-oam" {
          value 36;
          description "Match Type ATM OAM";
        }
        enum "match-type-atm-clp" {
          value 37;
          description "Match Type ATM CLP";
        }
        enum "match-type-fr-de" {
          value 38;
          description "Match Type FR DE";
        }
        enum "match-type-qos-grp" {
          value 39;
          description "Match Type QoS Group";
        }
        enum "match-type-traffic-class" {
          value 40;
          description
            "Match Type Traffic Class";
        }
        enum "match-type-disc-cls" {
          value 41;
          description
            "Match Type Discard Class";
        }
        enum "match-type-vpls-known" {
          value 42;
          description
            "Match Type VPLS Known";
        }
        enum "match-type-vpls-unknown" {
          value 43;
          description
            "Match Type VPLS Unknown";
        }
        enum "match-type-vpls-mcast" {
          value 44;
          description
            "Match Type VPLS Multicast";
        }
        enum "match-type-vpls-bcast" {
          value 45;
          description
            "Match Type VPLS Broadcast";
        }
        enum "match-type-vpls-control" {
          value 46;
          description
            "Match Type VPLS Control";
        }
        enum "match-type-ipv4-acl" {
          value 47;
          description "Match Type IPv4 ACL";
        }
        enum "match-type-ipv6-acl" {
          value 48;
          description "Match Type IPv6 ACL";
        }
        enum "match-type-flow-key" {
          value 49;
          description "Match Type Flow Key";
        }
        enum "match-type-avail-id" {
          value 50;
          description
            "Match Type Available Identifier";
        }
        enum "match-type-authen-status" {
          value 51;
          description
            "Match Type Authentication Status";
        }
        enum "match-type-media" {
          value 52;
          description "Match Type Media";
        }
        enum "match-type-mlp-negotiated" {
          value 53;
          description
            "Match Type MLP Negotiated";
        }
        enum "match-type-subs-protocol" {
          value 54;
          description "Match Type Protocol";
        }
        enum "match-type-dnis" {
          value 55;
          description "Match Type DNIS";
        }
        enum "match-type-dnis-regexp" {
          value 56;
          description
            "Match Type DNIS Regular Exp";
        }
        enum "match-type-domain" {
          value 57;
          description "Match Type Domain";
        }
        enum "match-type-domain-regexp" {
          value 58;
          description
            "Match Type Domain Regular Exp";
        }
        enum "match-type-nas-port" {
          value 59;
          description "Match Type NAS Port";
        }
        enum "match-type-service-name" {
          value 60;
          description
            "Match Type Service Name";
        }
        enum
          "match-type-service-name-regexp" {
          value 61;
          description
            "Match Type Service Name Regular Exp";
        }
        enum "match-type-src-addr-ipv4" {
          value 62;
          description
            "Match Type Source Address IPV4";
        }
        enum "match-type-dst-addr-ipv4" {
          value 63;
          description
            "Match Type Source Address IPV4";
        }
        enum "match-type-src-addr-ipv6" {
          value 64;
          description
            "Match Type Source Address IPV6";
        }
        enum "match-type-dst-addr-ipv6" {
          value 65;
          description
            "Match Type Source Address IPV6";
        }
        enum "match-type-src-addr-mac" {
          value 66;
          description
            "Match Type Source Address Mac";
        }
        enum "match-type-src-port" {
          value 67;
          description
            "Match Type Source Port";
        }
        enum "match-type-dst-port" {
          value 68;
          description
            "Match Type Source Port";
        }
        enum "match-type-timer" {
          value 69;
          description "Match Type Timer";
        }
        enum "match-type-timer-regexp" {
          value 70;
          description
            "Match Type Timer Regular Exp";
        }
        enum "match-type-tunnel-name" {
          value 71;
          description
            "Match Type Tunnel Name";
        }
        enum "match-type-tunnel-name-regexp" {
          value 72;
          description
            "Match Type Tunnel Name Regular Exp";
        }
        enum "match-type-user-name" {
          value 73;
          description "Match Type User Name";
        }
        enum "match-type-user-name-regexp" {
          value 74;
          description
            "Match Type User Name Regular Exp";
        }
        enum "match-type-auth-user-name" {
          value 75;
          description
            "Match Type Authenticated User Name";
        }
        enum
          "match-type-auth-user-name-regexp" {
          value 76;
          description
            "Match Type Authenticated Userame Reg Exp";
        }
        enum "match-type-unauth-user-name" {
          value 77;
          description
            "Match Type Unauthenticated Username";
        }
        enum
          "match-type-unauth-user-name-regexp" {
          value 78;
          description
            "Match Type Unauthenicated Username RegEx";
        }
        enum "match-type-no-user-name" {
          value 79;
          description
            "Match Type No Username";
        }
        enum "match-type-auth-domain" {
          value 80;
          description
            "Match Type Authenticated Domain";
        }
        enum "match-type-auth-domain-regexp" {
          value 81;
          description
            "Match Type Authenticated Domain RegEx";
        }
        enum "match-type-unauth-domain" {
          value 82;
          description
            "Match Type Unauthenticated Domain";
        }
        enum
          "match-type-unauth-domain-regexp" {
          value 83;
          description
            "Match Type Unauthenticated Domain RegEx";
        }
        enum "match-type-vendor-id" {
          value 84;
          description "Match Type Vendor ID";
        }
        enum "match-type-vendor-id-regexp" {
          value 85;
          description
            "Match Type Vendor ID RegEx";
        }
        enum "match-type-access-interface" {
          value 86;
          description
            "Match Type Access Interface";
        }
        enum "match-type-input-interface" {
          value 87;
          description
            "Match Type Input Interface";
        }
        enum
          "match-type-input-interface-hdl" {
          value 88;
          description
            "Match Type Input Interface handle";
        }
        enum "match-type-ether-type" {
          value 89;
          description
            "Match Type Ethernet Type";
        }
        enum "match-type-dhcp-client-id" {
          value 90;
          description "Match DHCP Client ID";
        }
        enum
          "match-type-dhcp-client-id-regexp" {
          value 91;
          description
            "Match DHCP Client ID RegEx";
        }
        enum "match-type-circuit-id" {
          value 92;
          description
            "Match Type Circuit ID";
        }
        enum "match-type-circuit-id-regexp" {
          value 93;
          description
            "Match Type Circuit ID RegEx";
        }
        enum "match-type-remote-id" {
          value 94;
          description "Match Type Remote ID";
        }
        enum "match-type-remote-id-regexp" {
          value 95;
          description
            "Match Type Remote ID RegEx";
        }
        enum "match-type-cac-admit-local" {
          value 96;
          description
            "Match Type CAC admitted";
        }
        enum "match-type-cac-unadmit-local" {
          value 97;
          description
            "Match Type CAC unadmitted";
        }
        enum "match-type-any-internal" {
          value 98;
          description
            "Match Type Any (Used only for class-default)";
        }
        enum
          "match-type-ethernet-service-s-acl" {
          value 99;
          description
            "Match Type Ethernet-Services ACL";
        }
        enum "match-type-ptrs" {
          value 100;
          description
            "Dummy match type for internal use";
        }
        enum "match-type-max" {
          value 101;
          description
            "Match Type Max (Invalid)";
        }
      }
      description "Match Type";
    }

    typedef Flow-key-en {
      type enumeration {
        enum "flow-key-invalid" {
          value 0;
          description "Flow key invalid";
        }
        enum "flow-key-src-ip" {
          value 1;
          description "Flow key source ip";
        }
        enum "flow-key-dst-ip" {
          value 2;
          description
            "Flow key destination ip";
        }
        enum "flow-key-five-tuple" {
          value 3;
          description "Flow key five tuple";
        }
        enum "flow-key-max" {
          value 4;
          description "Flow key max";
        }
      }
      description "Flow key en";
    }

    typedef Match-attr-e {
      type enumeration {
        enum "value" {
          value 0;
          description
            "Match attribute value";
        }
        enum "range" {
          value 1;
          description
            "Match attribute range";
        }
        enum "mask" {
          value 2;
          description "Match attribute mask";
        }
      }
      description "Match attribute type";
    }

    typedef Afmon-alarm-sev-en {
      type enumeration {
        enum "afmon-alm-none" {
          value 0;
          description "afmon alm none";
        }
        enum "afmon-alm-info" {
          value 1;
          description "afmon alm info";
        }
        enum "afmon-alm-notif" {
          value 2;
          description "afmon alm notif";
        }
        enum "afmon-alm-warn" {
          value 3;
          description "afmon alm warn";
        }
        enum "afmon-alm-error" {
          value 4;
          description "afmon alm error";
        }
        enum "afmon-alm-crit" {
          value 5;
          description "afmon alm crit";
        }
        enum "afmon-alm-alert" {
          value 6;
          description "afmon alm alert";
        }
        enum "afmon-alm-emerg" {
          value 7;
          description "afmon alm emerg";
        }
        enum "afmon-alm-sev-max" {
          value 8;
          description "afmon alm sev max";
        }
      }
      description "AFMon Alarm Severities";
    }

    typedef Acct-en {
      type enumeration {
        enum "policy-acct-evt-unspecified" {
          value 0;
          description
            "policy acct evt unspecified";
        }
        enum "policy-acct-evt-start" {
          value 1;
          description
            "policy acct evt start";
        }
        enum "policy-acct-evt-stop" {
          value 2;
          description "policy acct evt stop";
        }
        enum "policy-acct-evt-update" {
          value 3;
          description
            "policy acct evt update";
        }
      }
      description "Acct en";
    }

    typedef Match-logical-operator-en {
      type enumeration {
        enum "match-operator-unspecified" {
          value 0;
          description
            "match operator unspecified";
        }
        enum "match-equal-to" {
          value 1;
          description "match equal to";
        }
        enum "match-greater-than" {
          value 2;
          description "match greater than";
        }
        enum "match-greater-than-or-equal" {
          value 3;
          description
            "match greater than or equal";
        }
        enum "match-less-than" {
          value 4;
          description "match less than";
        }
        enum "match-less-than-or-equal" {
          value 5;
          description
            "match less than or equal";
        }
        enum "match-operator-max" {
          value 6;
          description "match operator max";
        }
      }
      description "Logical Operators";
    }

    typedef Pclass-diff-inbag {
      type uint64;
      description "Pclass diff inbag";
    }

    typedef Shared-bucket-name {
      type string {
        length "0..65";
      }
      description "Shared bucket name";
    }

    typedef Policy-param-unit-type {
      type enumeration {
        enum "policy-param-unit-invalid" {
          value 0;
          description
            "policy param unit invalid";
        }
        enum "policy-param-unit-bytes" {
          value 1;
          description
            "policy param unit bytes";
        }
        enum "policy-param-unit-kbytes" {
          value 2;
          description
            "policy param unit kbytes";
        }
        enum "policy-param-unit-mbytes" {
          value 3;
          description
            "policy param unit mbytes";
        }
        enum "policy-param-unit-gbytes" {
          value 4;
          description
            "policy param unit gbytes";
        }
        enum "policy-param-unit-bitsps" {
          value 5;
          description
            "policy param unit bitsps";
        }
        enum "policy-param-unit-kbitsps" {
          value 6;
          description
            "policy param unit kbitsps";
        }
        enum "policy-param-unit-mbitsps" {
          value 7;
          description
            "policy param unit mbitsps";
        }
        enum "policy-param-unit-gbitsps" {
          value 8;
          description
            "policy param unit gbitsps";
        }
        enum "policy-param-unit-cells-ps" {
          value 9;
          description
            "policy param unit cells ps";
        }
        enum "policy-param-unit-packets-ps" {
          value 10;
          description
            "policy param unit packets ps";
        }
        enum "policy-param-unit-us" {
          value 11;
          description "policy param unit us";
        }
        enum "policy-param-unit-ms" {
          value 12;
          description "policy param unit ms";
        }
        enum "policy-param-unit-seconds" {
          value 13;
          description
            "policy param unit seconds";
        }
        enum "policy-param-unit-packets" {
          value 14;
          description
            "policy param unit packets";
        }
        enum "policy-param-unit-cells" {
          value 15;
          description
            "policy param unit cells";
        }
        enum "policy-param-unit-percent" {
          value 16;
          description
            "policy param unit percent";
        }
        enum
          "policy-param-unit-per-thousand" {
          value 17;
          description
            "policy param unit per thousand";
        }
        enum "policy-param-unit-per-million" {
          value 18;
          description
            "policy param unit per million";
        }
        enum "policy-param-unit-hz" {
          value 19;
          description "policy param unit hz";
        }
        enum "policy-param-unit-khz" {
          value 20;
          description
            "policy param unit khz";
        }
        enum "policy-param-unit-mhz" {
          value 21;
          description
            "policy param unit mhz";
        }
        enum "policy-param-unit-ratio" {
          value 22;
          description
            "policy param unit ratio";
        }
        enum "policy-param-unit-max" {
          value 23;
          description
            "policy param unit max";
        }
      }
      description "Policy param unit type";
    }

    typedef Pevent-type-en {
      type enumeration {
        enum "pevent-type-unspecified" {
          value 0;
          description "Unspecified event";
        }
        enum "pevent-type-acct-logon" {
          value 1;
          description "Log on event";
        }
        enum "pevent-type-acct-logoff" {
          value 2;
          description "Log off event";
        }
        enum "pevent-type-credit-exhausted" {
          value 3;
          description
            "Credit exhausted event";
        }
        enum "pevent-type-idle-timeout" {
          value 4;
          description "Idle timeout event";
        }
        enum "pevent-type-absolute-timeout" {
          value 5;
          description
            "Absolute timeout event";
        }
        enum "pevent-type-quota-depleted" {
          value 6;
          description
            "Quota depletion event";
        }
        enum "pevent-type-service-start" {
          value 7;
          description "Service start event";
        }
        enum "pevent-type-service-stop" {
          value 8;
          description "Service stop event";
        }
        enum "pevent-type-session-start" {
          value 9;
          description "Session start event";
        }
        enum "pevent-type-session-activate" {
          value 10;
          description
            "Session activate event";
        }
        enum "pevent-type-session-restart" {
          value 11;
          description
            "Session restart event";
        }
        enum "pevent-type-session-stop" {
          value 12;
          description "Session stop event";
        }
        enum
          "pevent-type-session-disconnect" {
          value 13;
          description
            "Session disconnect event";
        }
        enum "pevent-type-session-update" {
          value 14;
          description "Session update event";
        }
        enum "pevent-type-flow-start" {
          value 15;
          description "Flow start event";
        }
        enum "pevent-type-flow-stop" {
          value 16;
          description "Flow stop event";
        }
        enum "pevent-type-accouting-start" {
          value 17;
          description
            "Accounting start event";
        }
        enum "pevent-type-acountng-g-stop" {
          value 18;
          description
            "Accounting stop event";
        }
        enum "pevent-type-acountng-g-update" {
          value 19;
          description
            "Accounting update event";
        }
        enum "pevent-type-timer-expiry" {
          value 20;
          description "Timer expierd event";
        }
        enum "pevent-type-threshold-reached" {
          value 21;
          description
            "Threshold reached event";
        }
        enum "pevent-type-ka-success" {
          value 22;
          description
            "Keep alive success event";
        }
        enum "pevent-type-ka-failure" {
          value 23;
          description
            "Keep alive failure event";
        }
        enum "pevent-type-link-up" {
          value 24;
          description "Link up event";
        }
        enum "pevent-type-link-down" {
          value 25;
          description "Link down event";
        }
        enum
          "pevent-type-authorization-failure" {
          value 26;
          description
            "Authorization failure event";
        }
        enum
          "pevent-type-authorization-no-response" {
          value 27;
          description
            "Authorization no response event";
        }
        enum
          "pevent-type-authentication-failure" {
          value 28;
          description
            "Authentication failure event";
        }
        enum
          "pevent-type-authentication-no-response" {
          value 29;
          description
            "Authentication no response event";
        }
        enum "pevent-type-exception" {
          value 30;
          description "Exception event";
        }
        enum "pevent-type-session-ident-chg" {
          value 31;
          description
            "Session identity change event";
        }
        enum "pevent-type-max" {
          value 32;
          description "Internal use only";
        }
      }
      description "Policy event enumeration";
    }

    typedef Afmon-react-parm-type-en {
      type enumeration {
        enum "afmon-react-parm-invalid" {
          value 0;
          description "invalid";
        }
        enum "afmon-react-parm-oper-id" {
          value 1;
          description "Operation ID";
        }
        enum "afmon-react-parm-crit-erion" {
          value 2;
          description "Criterion";
        }
        enum "afmon-react-parm-desc" {
          value 3;
          description "Description";
        }
        enum "afmon-react-parm-trig-value" {
          value 4;
          description "Trigger value";
        }
        enum "afmon-react-parm-trig-type" {
          value 5;
          description "Trigger Type";
        }
        enum "afmon-react-parm-action" {
          value 6;
          description "Action";
        }
        enum "afmon-react-parm-alm-type" {
          value 7;
          description "Alarm type";
        }
        enum "afmon-react-parm-alm-severity" {
          value 8;
          description "Alarm Severity";
        }
        enum "afmon-react-parm-max" {
          value 9;
          description
            "Maximum react parm type";
        }
      }
      description
        "(afmon) React submode param types";
    }

    typedef Plmgr-var-type-en {
      type enumeration {
        enum "plmgr-var-type-class-name" {
          value 0;
          description
            "plmgr var type class name";
        }
        enum "plmgr-var-type-uint8" {
          value 1;
          description "plmgr var type uint8";
        }
        enum "plmgr-var-type-uint16" {
          value 2;
          description
            "plmgr var type uint16";
        }
        enum "plmgr-var-type-uint32" {
          value 3;
          description
            "plmgr var type uint32";
        }
        enum "plmgr-var-type-param-uint32" {
          value 4;
          description
            "plmgr var type param uint32";
        }
        enum "plmgr-var-type-dscp" {
          value 5;
          description "plmgr var type dscp";
        }
        enum "plmgr-var-type-prec" {
          value 6;
          description "plmgr var type prec";
        }
        enum "plmgr-var-type-max" {
          value 7;
          description "plmgr var type max";
        }
      }
      description
        "Type of default variable values";
    }

    typedef Policy-map-name {
      type string {
        length "0..65";
      }
      description "Policy map name";
    }

    typedef Policy-action-attr-en {
      type enumeration {
        enum "action-attribute" {
          value 1;
          description "action attribute";
        }
        enum "sub-action-attribute" {
          value 2;
          description "sub action attribute";
        }
      }
      description
        "Policy action attribute enum";
    }

    typedef Policy-obj-enc-en {
      type enumeration {
        enum "policy-obj-enc-name" {
          value 0;
          description "Name of the Policy";
        }
        enum "policy-obj-enc-hdl" {
          value 1;
          description "Policy Handle";
        }
        enum "policy-obj-enc-var-idx" {
          value 2;
          description
            "Policy Variable Index";
        }
        enum "policy-obj-enc-in-line" {
          value 3;
          description "Inline Class";
        }
      }
      description
        "Child policy related encoding information";
    }

    typedef Plmgr-app-fwding-type-e {
      type enumeration {
        enum "layer2" {
          value 0;
          description
            " Forwarding type layer2";
        }
        enum "layer3" {
          value 1;
          description
            " Forwarding type layer3";
        }
        enum "any" {
          value 2;
          description "Forwarding type any";
        }
      }
      description "Forwarding types";
    }

    typedef Class-map-type-en {
      type enumeration {
        enum "class-map-type-none" {
          value 0;
          description "class map type none";
        }
        enum "class-map-type-qos" {
          value 1;
          description "class map type qos";
        }
        enum "class-map-type-pbr" {
          value 2;
          description "class map type pbr";
        }
        enum "class-map-type-traffic" {
          value 3;
          description
            "class map type traffic";
        }
        enum "class-map-type-subs-control" {
          value 4;
          description
            "class map type subs control";
        }
        enum "class-map-type-max" {
          value 5;
          description "class map type max";
        }
      }
      description "Class map type en";
    }

    typedef Wred-type-en {
      type enumeration {
        enum "wred-cos-cmd" {
          value 0;
          description "wred cos cmd";
        }
        enum "wred-dscp-cmd" {
          value 1;
          description "wred dscp cmd";
        }
        enum "wred-precedence-cmd" {
          value 2;
          description "wred precedence cmd";
        }
        enum "wred-discard-class-cmd" {
          value 3;
          description
            "wred discard class cmd";
        }
        enum "wred-mpls-exp-cmd" {
          value 4;
          description "wred mpls exp cmd";
        }
        enum "red-with-user-min-max" {
          value 5;
          description
            "red with user min max";
        }
        enum "red-with-default-min-max" {
          value 6;
          description
            "red with default min max";
        }
        enum "wred-dei-cmd" {
          value 7;
          description "wred dei cmd";
        }
        enum "wred-ecn-cmd" {
          value 8;
          description "wred ecn cmd";
        }
        enum "wred-invalid-cmd" {
          value 9;
          description "wred invalid cmd";
        }
      }
      description "Wred type en";
    }

    typedef Policy-map-table-type-en {
      type enumeration {
        enum "policy-map-table-type-none" {
          value 0;
          description
            "policy map table type none";
        }
        enum "policy-map-table-type-l2-any" {
          value 1;
          description
            "policy map table type l2 any";
        }
        enum "policy-map-table-type-l2-l3" {
          value 2;
          description
            "policy map table type l2 l3";
        }
        enum "policy-map-table-type-l3-ipv4" {
          value 3;
          description
            "policy map table type l3 ipv4";
        }
        enum "policy-map-table-type-l3-ds" {
          value 4;
          description
            "policy map table type l3 ds";
        }
        enum
          "policy-map-table-type-traffic-ingress" {
          value 5;
          description
            "policy map table type traffic ingress";
        }
        enum
          "policy-map-table-type-qos-ingress" {
          value 6;
          description
            "policy map table type qos ingress";
        }
        enum
          "policy-map-table-type-qos-egress" {
          value 7;
          description
            "policy map table type qos egress";
        }
        enum "policy-map-table-type-max" {
          value 8;
          description
            "policy map table type max";
        }
      }
      description "Policy-Map Table Type";
    }

    typedef Shared-bucket-type {
      type enumeration {
        enum
          "shared-bucket-type-not-specified" {
          value 0;
          description
            "shared bucket type not specified";
        }
        enum "shared-bucket-referred" {
          value 1;
          description
            "shared bucket referred";
        }
        enum "shared-bucket-defined" {
          value 2;
          description
            "shared bucket defined";
        }
      }
      description "Shared bucket type";
    }

    typedef Afmon-rtp-clock-rate-type-en {
      type enumeration {
        enum "afmon-rtp-cr-invalid" {
          value 0;
          description "afmon rtp cr invalid";
        }
        enum "afmon-rtp-cr-8k" {
          value 1;
          description "afmon rtp cr 8k";
        }
        enum "afmon-rtp-cr-16k" {
          value 2;
          description "afmon rtp cr 16k";
        }
        enum "afmon-rtp-cr-11025" {
          value 3;
          description "afmon rtp cr 11025";
        }
        enum "afmon-rtp-cr-22050" {
          value 4;
          description "afmon rtp cr 22050";
        }
        enum "afmon-rtp-cr-44100" {
          value 5;
          description "afmon rtp cr 44100";
        }
        enum "afmon-rtp-cr-48k" {
          value 6;
          description "afmon rtp cr 48k";
        }
        enum "afmon-rtp-cr-90k" {
          value 7;
          description "afmon rtp cr 90k";
        }
        enum "afmon-rtp-cr-27m" {
          value 8;
          description "afmon rtp cr 27m";
        }
        enum "afmon-rtp-cr-148500k" {
          value 9;
          description "afmon rtp cr 148500k";
        }
        enum "afmon-rtp-cr-148351k" {
          value 10;
          description "afmon rtp cr 148351k";
        }
        enum "afmon-rtp-cr-max" {
          value 11;
          description "afmon rtp cr max";
        }
      }
      description
        "Afmon rtp clock rate type en";
    }

    typedef Afmon-trig-relop-en {
      type enumeration {
        enum "afmon-trig-relop-invalid" {
          value 0;
          description
            "afmon trig relop invalid";
        }
        enum "afmon-trig-lt" {
          value 1;
          description "afmon trig lt";
        }
        enum "afmon-trig-le" {
          value 2;
          description "afmon trig le";
        }
        enum "afmon-trig-gt" {
          value 3;
          description "afmon trig gt";
        }
        enum "afmon-trig-ge" {
          value 4;
          description "afmon trig ge";
        }
        enum "afmon-trig-range" {
          value 5;
          description "afmon trig range";
        }
        enum "afmon-trig-relop-max" {
          value 6;
          description "afmon trig relop max";
        }
      }
      description "Afmon trig relop en";
    }

    typedef Match-no-username-en {
      type enumeration {
        enum
          "match-no-user-name-unspecified" {
          value 0;
          description
            "match no user name unspecified";
        }
        enum "match-no-user-name" {
          value 1;
          description "match no user name";
        }
        enum "match-user-name" {
          value 2;
          description "match user name";
        }
        enum "match-no-user-name-max" {
          value 3;
          description
            "match no user name max";
        }
      }
      description "Match no username en";
    }

    typedef Afmon-rtp-parm-type-en {
      type enumeration {
        enum "afmon-rtp-parm-invalid" {
          value 0;
          description
            "afmon rtp parm invalid";
        }
        enum "afmon-rtp-parm-min-seq" {
          value 1;
          description
            "afmon rtp parm min seq";
        }
        enum "afmon-rtp-parm-max-drop" {
          value 2;
          description
            "afmon rtp parm max drop";
        }
        enum "afmon-rtp-parm-max-mis-order" {
          value 3;
          description
            "afmon rtp parm max mis order";
        }
        enum "afmon-rtp-parm-seq-ext-cop4" {
          value 4;
          description
            "afmon rtp parm seq ext cop4";
        }
        enum "afmon-rtp-parm-clock-rate" {
          value 5;
          description
            "afmon rtp parm clock rate";
        }
        enum "afmon-rtp-parm-max" {
          value 6;
          description "afmon rtp parm max";
        }
      }
      description "Afmon rtp parm type en";
    }

    typedef Policy-map-type-en {
      type enumeration {
        enum "policy-map-type-none" {
          value 0;
          description "policy map type none";
        }
        enum "policy-map-type-qos" {
          value 1;
          description "policy map type qos";
        }
        enum "policy-map-type-pbr" {
          value 2;
          description "policy map type pbr";
        }
        enum "policy-map-type-traffic" {
          value 3;
          description
            "policy map type traffic";
        }
        enum "policy-map-type-subs-control" {
          value 4;
          description
            "policy map type subs control";
        }
        enum "policy-map-type-accounting" {
          value 5;
          description
            "policy map type accounting";
        }
        enum "policy-map-type-redirect" {
          value 6;
          description
            "policy map type redirect";
        }
        enum "policy-map-type-afmon" {
          value 7;
          description
            "policy map type afmon";
        }
        enum "policy-map-type-merge" {
          value 8;
          description
            "policy map type merge";
        }
        enum "policy-map-type-max" {
          value 9;
          description "policy map type max";
        }
      }
      description "Policy map type en";
    }

    typedef Redirect-type-en {
      type enumeration {
        enum "redirect-type-none" {
          value 0;
          description "Redirect None";
        }
        enum
          "redirect-type-output-interface" {
          value 1;
          description
            "Redirect to output intreface";
        }
        enum "redirect-type-max" {
          value 2;
          description
            "Redirect Max (Invalid)";
        }
      }
      description
        "Redirect types Enumeration";
    }

    typedef Policy-action-exec-type-e {
      type enumeration {
        enum "execution-immediate" {
          value 1;
          description "execution immediate";
        }
        enum "execution-deferred" {
          value 2;
          description "execution deferred";
        }
      }
      description
        "Policy action execution type enum";
    }

    typedef Class-map-mode-en {
      type enumeration {
        enum "class-map-mode-match-any" {
          value 0;
          description "Type Match-Any";
        }
        enum "class-map-mode-match-all" {
          value 1;
          description "Type Match-All";
        }
        enum "class-map-mode-max" {
          value 2;
          description "Not a valid mode";
        }
        enum "class-map-mode-usr-def" {
          value 1073741824;
          description
            "User defined match type";
        }
      }
      description "Class-Map Mode";
    }

    typedef Match-subs-protocol-en {
      type enumeration {
        enum
          "match-subs-protocol-unspecified" {
          value 0;
          description
            "match subs protocol unspecified";
        }
        enum "match-subs-protocol-ipv4" {
          value 1;
          description
            "match subs protocol ipv4";
        }
        enum "match-subs-protocol-ppp" {
          value 2;
          description
            "match subs protocol ppp";
        }
        enum "match-subs-protocol-dhcpv4" {
          value 3;
          description
            "match subs protocol dhcpv4";
        }
        enum "match-subs-protocol-dhcpv6" {
          value 4;
          description
            "match subs protocol dhcpv6";
        }
        enum "match-subs-protocol-max" {
          value 5;
          description
            "match subs protocol max";
        }
      }
      description "Match subs protocol en";
    }

    typedef Vsvc-service-type-t {
      type enumeration {
        enum "vsvc-service-invalid" {
          value 0;
          description "vsvc service invalid";
        }
        enum "vsvc-service-v-path" {
          value 1;
          description "vsvc service v path";
        }
        enum "vsvc-service-ipsec" {
          value 2;
          description "vsvc service ipsec";
        }
        enum "vsvc-service-cgn" {
          value 3;
          description "vsvc service cgn";
        }
        enum "vsvc-service-o-flow" {
          value 4;
          description "vsvc service o flow";
        }
        enum "vsvc-service-output" {
          value 5;
          description "vsvc service output";
        }
        enum "vsvc-service-cfg-v-path" {
          value 6;
          description
            "vsvc service cfg v path";
        }
        enum "vsvc-service-sfp" {
          value 7;
          description "vsvc service sfp";
        }
        enum "vsvc-service-sfl" {
          value 8;
          description "vsvc service sfl";
        }
        enum "vsvc-service-sffl" {
          value 9;
          description "vsvc service sffl";
        }
        enum "vsvc-service-max" {
          value 10;
          description "vsvc service max";
        }
      }
      description "Vsvc service type t";
    }

    typedef Afmon-flow-parm-type-en {
      type enumeration {
        enum "afmon-flow-parm-invalid" {
          value 0;
          description "invalid";
        }
        enum
          "afmon-flow-parm-max-mon-flow-s" {
          value 1;
          description "Max monitored flows";
        }
        enum "afmon-flow-parm-mon-interval" {
          value 2;
          description "Monitoring interval";
        }
        enum "afmon-flow-parm-intvl-hist" {
          value 3;
          description "Interval History";
        }
        enum "afmon-flow-parm-flow-timeout" {
          value 4;
          description "Flow Timeout";
        }
        enum "afmon-flow-parm-max" {
          value 5;
          description
            "Maximum flow parm type";
        }
      }
      description
        "(afmon) Flow submode param types";
    }

    typedef Afmon-trig-type-en {
      type enumeration {
        enum "afmon-trig-type-invalid" {
          value 0;
          description
            "afmon trig type invalid";
        }
        enum "afmon-trig-immed" {
          value 1;
          description "afmon trig immed";
        }
        enum "afmon-trig-avg" {
          value 2;
          description "afmon trig avg";
        }
        enum "afmon-trig-type-max" {
          value 3;
          description "afmon trig type max";
        }
      }
      description "Afmon trig type en";
    }

    typedef Match-authen-status-en {
      type enumeration {
        enum
          "match-authen-status-unspecified" {
          value 0;
          description
            "match authen status unspecified";
        }
        enum
          "match-authen-status-authenticated" {
          value 1;
          description
            "match authen status authenticated";
        }
        enum
          "match-authen-status-unauthenticated" {
          value 2;
          description
            "match authen status unauthenticated";
        }
        enum "match-authen-status-max" {
          value 3;
          description
            "match authen status max";
        }
      }
      description "Match authen status en";
    }

    typedef Policy-class-info-en {
      type enumeration {
        enum "policy-class-info-key-type" {
          value 0;
          description
            "Policy Class Info Key";
        }
        enum "policy-class-info-mod-type" {
          value 1;
          description
            "Policy Class Info Modify Bag";
        }
      }
      description "Policy class info en";
    }

    typedef Afmon-mdi-parm-type-en {
      type enumeration {
        enum "afmon-mdi-parm-invalid" {
          value 0;
          description
            "afmon mdi parm invalid";
        }
        enum "afmon-mdi-parm-pids" {
          value 1;
          description "afmon mdi parm pids";
        }
        enum "afmon-mdi-parm-pkt-rate" {
          value 2;
          description
            "afmon mdi parm pkt rate";
        }
        enum "afmon-mdi-parm-ip-pkt-rate" {
          value 3;
          description
            "afmon mdi parm ip pkt rate";
        }
        enum "afmon-mdi-parm-ip-bit-rate" {
          value 4;
          description
            "afmon mdi parm ip bit rate";
        }
        enum "afmon-mdi-parm-max" {
          value 5;
          description "afmon mdi parm max";
        }
      }
      description "Afmon mdi parm type en";
    }

    typedef Police-action-type-en {
      type enumeration {
        enum "police-action-none" {
          value 0;
          description "Policer Action None";
        }
        enum "police-action-transmit" {
          value 1;
          description
            "Policer Action Transmit";
        }
        enum "police-action-drop" {
          value 2;
          description "Policer Action Drop";
        }
        enum "police-action-mark" {
          value 3;
          description "Policer Action Mark";
        }
        enum "police-action-max" {
          value 4;
          description "Policer Action Max";
        }
      }
      description "Policer Action Type";
    }

    typedef Match-mlp-negotiated-en {
      type enumeration {
        enum
          "match-mlp-negotiated-unspecified" {
          value 0;
          description
            "match mlp negotiated unspecified";
        }
        enum "match-mlp-negotiated" {
          value 1;
          description "match mlp negotiated";
        }
        enum "match-mlp-not-negotiated" {
          value 2;
          description
            "match mlp not negotiated";
        }
        enum "match-mlp-max" {
          value 3;
          description "match mlp max";
        }
      }
      description "Match mlp negotiated en";
    }

    typedef Match-cap-e {
      type uint8;
      description "Match cap e";
    }

    typedef Policy-action-e {
      type uint8;
      description "Policy action e";
    }

    typedef Match-nas-port-intf-type-en {
      type enumeration {
        enum
          "match-nas-port-intf-type-unspecified" {
          value 0;
          description
            "match nas port intf type unspecified";
        }
        enum
          "match-nas-port-intf-type-async" {
          value 1;
          description
            "match nas port intf type async";
        }
        enum "match-nas-port-intf-type-atm" {
          value 2;
          description
            "match nas port intf type atm";
        }
        enum "match-nas-port-intf-type-bri" {
          value 3;
          description
            "match nas port intf type bri";
        }
        enum
          "match-nas-port-intf-type-ether" {
          value 4;
          description
            "match nas port intf type ether";
        }
        enum
          "match-nas-port-intf-type-ipsec" {
          value 5;
          description
            "match nas port intf type ipsec";
        }
        enum "match-nas-port-intf-type-none" {
          value 6;
          description
            "match nas port intf type none";
        }
        enum
          "match-nas-port-intf-type-piafs" {
          value 7;
          description
            "match nas port intf type piafs";
        }
        enum
          "match-nas-port-intf-type-pppatm" {
          value 8;
          description
            "match nas port intf type pppatm";
        }
        enum
          "match-nas-port-intf-type-ppp-ether" {
          value 9;
          description
            "match nas port intf type ppp ether";
        }
        enum
          "match-nas-port-intf-type-pppoeatm" {
          value 10;
          description
            "match nas port intf type pppoeatm";
        }
        enum
          "match-nas-port-intf-type-pppqinq" {
          value 11;
          description
            "match nas port intf type pppqinq";
        }
        enum
          "match-nas-port-intf-type-pppvlan" {
          value 12;
          description
            "match nas port intf type pppvlan";
        }
        enum "match-nas-port-intf-type-pri" {
          value 13;
          description
            "match nas port intf type pri";
        }
        enum "match-nas-port-intf-type-sync" {
          value 14;
          description
            "match nas port intf type sync";
        }
        enum "match-nas-port-intf-type-v110" {
          value 15;
          description
            "match nas port intf type v110";
        }
        enum "match-nas-port-intf-type-v120" {
          value 16;
          description
            "match nas port intf type v120";
        }
        enum "match-nas-port-intf-type-vty" {
          value 17;
          description
            "match nas port intf type vty";
        }
        enum "match-nas-port-intf-type-x75" {
          value 18;
          description
            "match nas port intf type x75";
        }
        enum "match-nas-port-intf-type-max" {
          value 19;
          description
            "match nas port intf type max";
        }
      }
      description
        "Match nas port intf type en";
    }

    grouping DEI-BIT {
      description "DEI BIT";
      uses DEI-BIT-ST;
    }  // grouping DEI-BIT

    grouping UINT64-ARRAY {
      description "UINT64 ARRAY";
      leaf-list uint64_array {
        type uint64;
        description "uint64 array";
      }
    }  // grouping UINT64-ARRAY

    grouping DEI-BIT-ST {
      description "DEI BIT ST";
      leaf bit-value {
        type uint32;
        description "Value of the DEI bit";
      }
    }  // grouping DEI-BIT-ST

    grouping ACTION-PBF-INFO-ST {
      description "action pbr pbf";
      leaf addr {
        type inet:ipv6-address;
        description "v4 or v6 address";
      }

      leaf vrf {
        type string;
        description "vrf name";
      }

      leaf rt-type {
        type uint8;
        description "route target type";
      }

      leaf rt {
        type yang:hex-string;
        description "route target";
      }
    }  // grouping ACTION-PBF-INFO-ST

    grouping MAC-ADDR-ARRAY {
      description "MAC ADDR ARRAY";
      list mac-addr-array {
        description "mac addr array";
        uses MAC-ADDR-ST;
      }  // list mac-addr-array
    }  // grouping MAC-ADDR-ARRAY

    grouping ACTION-SERVICE-FUNCTION-PATH-ST {
      description "service function path";
      leaf path-id {
        type uint32;
        description "service path id";
      }

      leaf service-index {
        type uint8;
        description "service path index";
      }

      leaf meta-name {
        type string;
        description "metadata name";
      }

      leaf vs-index {
        type uint32;
        description "vservice index";
      }
    }  // grouping ACTION-SERVICE-FUNCTION-PATH-ST

    grouping ACTION-AFMON-FMM-INFO-P {
      description "ACTION AFMON FMM INFO P";
      uses ACTION-AFMON-FMM-INFO-ST;
    }  // grouping ACTION-AFMON-FMM-INFO-P

    grouping ACTION-MARK2-INFO {
      description "ACTION MARK2 INFO";
      list action-mark2-info {
        description "action mark2 info";
        uses ACTION-MARK2-INFO-ST;
      }  // list action-mark2-info
    }  // grouping ACTION-MARK2-INFO

    grouping ACTION-AUTHEN-AAA-INFO-P {
      description "ACTION AUTHEN AAA INFO P";
      uses ACTION-AUTHEN-AAA-ST;
    }  // grouping ACTION-AUTHEN-AAA-INFO-P

    grouping ACTION-IPV4-NH-INFO-ST {
      description "ipv4 next hop action";
      leaf ipv4-nh-addr {
        type inet:ipv4-address;
        description "nh addr";
      }

      leaf vrf-name {
        type string;
        description "Vrf name";
      }
    }  // grouping ACTION-IPV4-NH-INFO-ST

    grouping ACTION-AFMON-REACT-ST {
      description
        "AFMon React Configuration";
      leaf oper-id {
        type uint32;
        description "React Operation ID";
      }

      leaf description {
        type string;
        description "Describing the oper";
      }

      leaf trig-num-intvls {
        type uint32;
        description "Averaged over N intvls";
      }

      leaf clone-ifh {
        type uint32;
        description "Clone interface handle";
      }

      leaf notif-actns {
        type uint8;
        description
          "Bitmap of actions on alert";
      }

      leaf criterion {
        type uint8;
        description "React Criterion";
      }

      leaf trig-type {
        type uint8;
        description
          "Immediate or averaged thresh trigger";
      }

      leaf trig-relop {
        type uint8;
        description
          "Trigger LT|LE|GT|GE|Range";
      }

      leaf trig-level-1 {
        type string;
        description
          "Trigger threshold 1/lower";
      }

      leaf trig-level-2 {
        type string;
        description
          "Trigger upper threshold for range";
      }

      leaf alm-grp-thresh {
        type uint16;
        units "percentage";
        description "Num/percent in grp";
      }

      leaf alm-type {
        type uint8;
        description
          "Discrete | grouped alarm";
      }

      leaf alm-severity {
        type uint8;
        description "Major|Minor|... alarm";
      }
    }  // grouping ACTION-AFMON-REACT-ST

    grouping ACTION-STOP-TIMER-INFO-P {
      description "ACTION STOP TIMER INFO P";
      uses ACTION-STOP-TIMER-ST;
    }  // grouping ACTION-STOP-TIMER-INFO-P

    grouping PMAP-VAR-LIST-ST {
      description "PMAP VAR LIST ST";
      list pmap-var-list-arr {
        description "pmap var list arr";
        uses PMAP-VAR-INFO-ST;
      }  // list pmap-var-list-arr
    }  // grouping PMAP-VAR-LIST-ST

    grouping ACTION-AFMON-MDI-INFO-ST {
      description "AFMon MDI Configuration";
      container ip-bit-rate {
        description "data rate in bps";
        uses POLICY-PARAM-UINT32-ST;
      }  // container ip-bit-rate

      leaf action-metric-type {
        type Policy-action-en;
        description "metric type";
      }

      leaf filtered-pkt-rate {
        type uint32;
        description "filtered packet rate";
      }

      leaf ip-pkt-rate {
        type uint32;
        description "packet rate in pps";
      }

      leaf-list pids {
        type uint32;
        description
          "array of monitoredcd  pids";
      }
    }  // grouping ACTION-AFMON-MDI-INFO-ST

    grouping INLINE-CLASS-MAP-BG {
      description "Inline Class-map bag";
      container match-infop {
        description
          "Pointer to the first Match info";
        uses CLASS-MATCH-INFO-ST;
      }  // container match-infop

      leaf mode {
        type Class-map-mode-en;
        description
          "Inline Class-Map Mode Match any/all";
      }

      leaf flags {
        type uint32;
        description "Inline Class-Map flags";
      }

      leaf match-count {
        type uint32;
        description "Number of Match infos";
      }
    }  // grouping INLINE-CLASS-MAP-BG

    grouping ACTION-AFMON-FLOW-PARM-INFO-ST {
      description
        "(afmon) flow-parm submode action";
      leaf max-mon-flows {
        type uint32;
        description
          "max simult flows monitored per policy class";
      }

      leaf mon-interval {
        type uint32;
        units "second";
        description
          "monitored interval duration in secs";
      }

      leaf intvl-hist {
        type uint32;
        description
          "num intervals of data stored on rtr";
      }

      leaf flow-timeout {
        type uint32;
        units "second";
        description "timeout in secs";
      }
    }  // grouping ACTION-AFMON-FLOW-PARM-INFO-ST

    grouping ACTION-TIMEOUT-IDLE-INFO-P {
      description
        "ACTION TIMEOUT IDLE INFO P";
      uses ACTION-TIMEOUT-IDLE-ST;
    }  // grouping ACTION-TIMEOUT-IDLE-INFO-P

    grouping ACTION-ACCOUNTING-EVENT-ST {
      description
        "ACTION ACCOUNTING EVENT ST";
      leaf action {
        type Acct-en;
        description "action";
      }

      leaf aaa-list-name {
        type string;
        description "aaa list name";
      }
    }  // grouping ACTION-ACCOUNTING-EVENT-ST

    grouping PLMGR-VRF-STATS-BG {
      description
        "List of Stats of all class type";
      leaf pmap-name {
        type string;
        description "pmap name";
      }

      list cmap-stats-arr {
        description "cmap stats arr";
        uses PLMGR-CMAP-STATS-ARR-ST;
      }  // list cmap-stats-arr
    }  // grouping PLMGR-VRF-STATS-BG

    grouping POLICY-MAP-BG {
      description "Policy-map Bag";
      list policy-map-bg {
        description "policy map bg";
        container pmap-var-list {
          description
            "contains variable argument data";
          uses PMAP-VAR-LIST-ST;
        }  // container pmap-var-list

        container event-infop {
          description "event infop";
          uses POLICY-EVENT-INFO-BG;
        }  // container event-infop

        leaf name {
          type Policy-map-name;
          description "name";
        }

        leaf type {
          type Policy-map-type-en;
          description "type";
        }

        leaf description {
          type string;
          description "description";
        }
      }  // list policy-map-bg
    }  // grouping POLICY-MAP-BG

    grouping MATCH-IPV4-ST {
      description "Source Address IPv4";
      leaf prefix {
        type inet:ipv4-address;
        description "prefix";
      }

      leaf mask {
        type inet:ipv4-address;
        description "mask";
      }
    }  // grouping MATCH-IPV4-ST

    grouping ACTION-IPV4-NH-INFO-P {
      description "ACTION IPV4 NH INFO P";
      uses ACTION-IPV4-NH-INFO-ARRAY;
    }  // grouping ACTION-IPV4-NH-INFO-P

    grouping ACTION-QLIMIT-INFO-ST {
      description "Queue Limit structure";
      container qlim {
        description "qlim";
        uses POLICY-PARAM-UINT32-ST;
      }  // container qlim

      container atmclp-qlim {
        description "atmclp qlim";
        uses POLICY-PARAM-UINT32-ST;
      }  // container atmclp-qlim

      container match-values {
        description "match values";
        uses UINT8-RNG-ARRAY;
      }  // container match-values

      leaf type {
        type Qlimit-type-en;
        description "type";
      }

      leaf qlimit-flags {
        type uint32;
        description "qlimit flags";
      }
    }  // grouping ACTION-QLIMIT-INFO-ST

    grouping POLICY-MAP-APPLIED-SHOW-BG {
      description
        "Policy-map applied show bag";
      leaf parent-pmap-name {
        type Policy-map-name;
        description "parent pmap name";
      }

      leaf pmap-type {
        type Policy-map-type-en;
        description "pmap type";
      }

      leaf-list subscriber-grp {
        type Object-name;
        description "subscriber grp";
      }

      list pmaps {
        description "pmaps";
        uses POLICY-MAP-BG;
      }  // list pmaps

      list pmap-var-list {
        description "pmap var list";
        uses PLMGR-APPLIED-VARLIST-BG;
      }  // list pmap-var-list
    }  // grouping POLICY-MAP-APPLIED-SHOW-BG

    grouping POLICY-PARAM-UINT32-ST {
      description "POLICY PARAM UINT32 ST";
      leaf value {
        type uint32;
        description "value";
      }

      leaf unit {
        type Policy-param-unit-type;
        description "unit";
      }
    }  // grouping POLICY-PARAM-UINT32-ST

    grouping ACTION-PFC-INFO-P {
      description "ACTION PFC INFO P";
      uses ACTION-PFC-INFO-ST;
    }  // grouping ACTION-PFC-INFO-P

    grouping VALUE-ATTR-T {
      description
        " Value attribute for a match type";
      leaf minimum {
        type uint32;
        description
          "Minimum value for a match type";
      }

      leaf maximum {
        type uint32;
        description
          "Maximum value for a match type";
      }
    }  // grouping VALUE-ATTR-T

    grouping POLICY-MAP-APPLIED-DATA-BG {
      description
        "Policy-map applied data bag";
      leaf applied-pmap-name {
        type Policy-map-name;
        description "applied pmap name";
      }

      leaf pmap-type {
        type Policy-map-type-en;
        description "pmap type";
      }

      leaf-list merged-pmap-name-arr {
        type Policy-map-name;
        description "merged pmap name arr";
      }

      leaf-list subscriber-grp {
        type Object-name;
        description "subscriber grp";
      }

      list pmap-var-list {
        description "pmap var list";
        uses PLMGR-APPLIED-VARLIST-BG;
      }  // list pmap-var-list
    }  // grouping POLICY-MAP-APPLIED-DATA-BG

    grouping PACTION-DATA-HD {
      description "PACTION DATA HD";
      uses POLICY-ACTION-INFO-ST;
    }  // grouping PACTION-DATA-HD

    grouping PLMGR-CMAP-DIFF-BG {
      description "Class-map diff Bag";
      container del {
        description "del";
        uses CLASS-MAP-BG;
      }  // container del

      container add {
        description "add";
        uses CLASS-MAP-BG;
      }  // container add
    }  // grouping PLMGR-CMAP-DIFF-BG

    grouping ACTION-MARK-INFO {
      description "ACTION MARK INFO";
      list action-mark-info {
        description "action mark info";
        uses ACTION-MARK-INFO-ST;
      }  // list action-mark-info
    }  // grouping ACTION-MARK-INFO

    grouping POLICY-CLASS-INFO-MOD-BG {
      description "Policy-class modify Bag";
      list policy-class-info-mod-bg {
        description
          "policy class info mod bg";
        container new-value {
          description "new value";
          uses POLICY-CLASS-INFO-BG;
        }  // container new-value

        container old-value {
          description "old value";
          uses POLICY-CLASS-INFO-BG;
        }  // container old-value
      }  // list policy-class-info-mod-bg
    }  // grouping POLICY-CLASS-INFO-MOD-BG

    grouping POLICY-ACTION-INFO-ST {
      description
        "Per class action structure";
      list policy-action-info-st {
        description "policy action info st";
        container actp {
          description "actp";
          uses POLICY-ACTION-DATAP-UN;
        }  // container actp

        leaf seq {
          type uint16;
          description "seq";
        }

        leaf flags {
          type uint16;
          description "flags";
        }
      }  // list policy-action-info-st
    }  // grouping POLICY-ACTION-INFO-ST

    grouping CMATCH-DATA-HD {
      description "CMATCH DATA HD";
      uses CLASS-MATCH-INFO-ST;
    }  // grouping CMATCH-DATA-HD

    grouping ACTION-QLIMIT-INFO-P {
      description "ACTION QLIMIT INFO P";
      uses ACTION-QLIMIT-INFO-ARRAY;
    }  // grouping ACTION-QLIMIT-INFO-P

    grouping PLMGR-APP-TB-ACTION-CAP-T {
      description "Policy action capability";
      container policy-action-attribute {
        description
          "Policy Action attribute  info";
        uses PLMGR-ACTION-ATTR-UN;
      }  // container policy-action-attribute

      leaf policy-action {
        type Policy-action-e;
        description "Policy action ";
      }
    }  // grouping PLMGR-APP-TB-ACTION-CAP-T

    grouping PLMGR-CMAP-STATS-ARR-ST {
      description "Statistics per ClassMap";
      leaf cmap-name {
        type string {
          length "0..65";
        }
        description "cmap name";
      }

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

      leaf matched-packets {
        type uint64;
        description "matched packets";
      }

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

      leaf transmit-packets {
        type uint64;
        description "transmit packets";
      }
    }  // grouping PLMGR-CMAP-STATS-ARR-ST

    grouping POL-CLASS-ENC-UN {
      description
        "Union of object name and app object ptr";
      container inline-cmap {
        when
          "../enc = 'policy-obj-enc-in-line'" {
          description
            "../enc = 'POLICY_OBJ_ENC_INLINE'";
        }
        description "inline cmap";
        uses INLINE-CLASS-MAP-BG;
      }  // container inline-cmap

      leaf enc {
        type Policy-obj-enc-en;
        description "enc";
      }

      leaf class-name {
        when
          "../enc = 'policy-obj-enc-name'" {
          description
            "../enc = 'POLICY_OBJ_ENC_NAME'";
        }
        type Class-map-name;
        description "class name";
      }

      leaf hd {
        when "../enc = 'policy-obj-enc-hdl'" {
          description
            "../enc = 'POLICY_OBJ_ENC_HDL'";
        }
        type uint64;
        description "hd";
      }

      leaf idx {
        when
          "../enc = 'policy-obj-enc-var-idx'" {
          description
            "../enc = 'POLICY_OBJ_ENC_VAR_IDX'";
        }
        type uint8;
        description "idx";
      }
    }  // grouping POL-CLASS-ENC-UN

    grouping ACTION-SERVICE-FUNCTION-PATH-P {
      description
        "ACTION SERVICE FUNCTION PATH P";
      uses ACTION-SERVICE-FUNCTION-PATH-ST;
    }  // grouping ACTION-SERVICE-FUNCTION-PATH-P

    grouping ACTION-SHAPE-INFO-STR {
      description "ACTION POLICE INFO ARRAY";
      list action-shape-info-st {
        description
          "action police info array";
        uses ACTION-SHAPE-INFO-ST;
      }  // list action-shape-info-st
    }  // grouping ACTION-SHAPE-INFO-STR

    grouping ACTION-SHAPE-INFO-ST {
      description "Shape info bag";
      container bw {
        description "bw";
        uses POLICY-PARAM-UINT32-ST;
      }  // container bw

      container be {
        description "be";
        uses POLICY-PARAM-UINT32-ST;
      }  // container be
    }  // grouping ACTION-SHAPE-INFO-ST

    grouping ACTION-SERVICE-POLICY-INFO-P {
      description
        "ACTION SERVICE POLICY INFO P";
      uses CHLD-POL-ENC-UN;
    }  // grouping ACTION-SERVICE-POLICY-INFO-P

    grouping ACTION-PFC-INFO {
      description "ACTION PFC INFO";
      list action-pfc-info-st {
        description "action pfc info st";
        uses ACTION-PFC-INFO-ST;
      }  // list action-pfc-info-st
    }  // grouping ACTION-PFC-INFO

    grouping ACTION-PFC-INFO-ST {
      description "Pfc info bag";
      container buffer-size {
        description "buffer size";
        uses POLICY-PARAM-UINT32-ST;
      }  // container buffer-size

      container pause-threshold {
        description "pause threshold";
        uses POLICY-PARAM-UINT32-ST;
      }  // container pause-threshold

      container resume-threshold {
        description "resume threshold";
        uses POLICY-PARAM-UINT32-ST;
      }  // container resume-threshold

      leaf pfc-pause-set {
        type uint32;
        description "pfc pause set";
      }

      leaf buffer-size-flag {
        type uint32;
        description "buffer size flag";
      }
    }  // grouping ACTION-PFC-INFO-ST

    grouping MATCH-NAS-PORT-ST {
      description "NAS Port";
      leaf sub-id {
        type Match-nas-port-sub-id-en;
        description "sub id";
      }

      leaf operator {
        type Match-logical-operator-en;
        description "operator";
      }

      leaf value {
        type uint32;
        description "value";
      }
    }  // grouping MATCH-NAS-PORT-ST

    grouping PLMGR-APP-GL-COOKIE-CAP-T {
      description
        "Cookie capability of a network element";
      leaf policy-map-cookie {
        type boolean;
        description
          "Specifies policy-map cookie supported or not";
      }

      leaf inline-class-cookie {
        type boolean;
        description
          "Specifies class cookie supported or not";
      }
    }  // grouping PLMGR-APP-GL-COOKIE-CAP-T

    grouping CMAP-DATA-HD {
      description "CMAP DATA HD";
      uses CLASS-MAP-BG;
    }  // grouping CMAP-DATA-HD

    grouping ACTION-AUTHEN-AAA-ST {
      description
        "Authenticate AAA list info";
      leaf aaa-list-name {
        type string;
        description "aaa list name";
      }

      leaf authen-password {
        type string;
        description "authen password";
      }
    }  // grouping ACTION-AUTHEN-AAA-ST

    grouping ACTION-SET-TIMER-INFO-P {
      description "ACTION SET TIMER INFO P";
      uses ACTION-SET-TIMER-ST;
    }  // grouping ACTION-SET-TIMER-INFO-P

    grouping MAC-ADDR-ST {
      description "MAC ADDR ST";
      list mac-addr {
        max-elements 3;
        description "MAC address list";
        leaf mac {
          type uint16;
          description "MAC address";
        }
      }  // list mac-addr

      list mac-mask {
        max-elements 3;
        description "MAC mask list";
        leaf mask {
          type uint16;
          description "MAC mask";
        }
      }  // list mac-mask
    }  // grouping MAC-ADDR-ST

    grouping PLMGR-ACTION-ATTR-UN {
      description
        "Union of default values corrosponding to variable
       type";
      container sub-action {
        when
          "../action-type = 'sub-action-attribute'" {
          description
            "../action_type = 'SubActionAttribute'";
        }
        description "sub action";
        uses POLICY-SUB-ACTIONS-T;
      }  // container sub-action

      container action-attr {
        when
          "../action-type = 'action-attribute'" {
          description
            "../action_type = 'ActionAttribute'";
        }
        description "action attr";
        uses POLICY-ACTION-ATTR-T;
      }  // container action-attr

      leaf action-type {
        type Policy-action-attr-en;
        description "action type";
      }
    }  // grouping PLMGR-ACTION-ATTR-UN

    grouping PLMGR-APP-GL-SYSTEM-CAP-T {
      description
        "System level capability of a network element";
      leaf maximum-inline-classes-per-system {
        type uint32;
        description
          "Maximum number of inline classes supported on a
         network element";
      }

      leaf maximum-policy-maps-per-system {
        type uint32;
        description
          "Maximum number of unique policy-map supported on
         a network element";
      }
    }  // grouping PLMGR-APP-GL-SYSTEM-CAP-T

    grouping ACTION-PRIO-INFO-ST {
      description "Priority action";
      leaf prio-lvl {
        type uint32;
        description "prio lvl";
      }
    }  // grouping ACTION-PRIO-INFO-ST

    grouping ACTION-AFMON-RTP-INFO-P {
      description "ACTION AFMON RTP INFO P";
      uses ACTION-AFMON-RTP-INFO-ST;
    }  // grouping ACTION-AFMON-RTP-INFO-P

    grouping PLMGR-MATCH-ATTR-UN {
      description
        "Union of default values corrosponding to variable
       type";
      container val-attr {
        when "../match-attr-type = 'value'" {
          description
            "../match_attr_type = 'Value'";
        }
        description "val attr";
        uses VALUE-ATTR-T;
      }  // container val-attr

      container rng-attr {
        when "../match-attr-type = 'range'" {
          description
            "../match_attr_type = 'Range'";
        }
        description "rng attr";
        uses VALUE-ATTR-T;
      }  // container rng-attr

      container mask-attr {
        when "../match-attr-type = 'mask'" {
          description
            "../match_attr_type = 'Mask'";
        }
        description "mask attr";
        uses MASK-ATTR-T;
      }  // container mask-attr

      leaf match-attr-type {
        type Match-attr-e;
        description "match attr type";
      }
    }  // grouping PLMGR-MATCH-ATTR-UN

    grouping UINT16-RNG-ARRAY {
      description "UINT16 RNG ARRAY";
      list uint16_rng_array {
        description "uint16 rng array";
        uses UINT16-RNG-ST;
      }  // list uint16_rng_array
    }  // grouping UINT16-RNG-ARRAY

    grouping PLMGR-PMAP-TARGETS-SUMMARY-BG {
      description
        "Policymap targets summary info. returned to show
       client(from policymgr)";
      leaf total-policy-maps-input-direction {
        type uint32;
        description
          "Total policymapsin the input direction";
      }

      leaf total-policy-maps-output-direction {
        type uint32;
        description
          "Total policymapsin the output direction";
      }

      leaf total-child-policy-maps-input-direction {
        type uint32;
        description
          "Totalpolicymaps applied as child policy in the
         input direction";
      }

      leaf total-child-policy-maps-output-direction {
        type uint32;
        description
          "Totalpolicymaps applied as child policy in the
         output direction";
      }

      leaf total-interfaces-input-direction {
        type uint32;
        description
          "Totalinterfaces with service-policy in the input
         direction";
      }

      leaf total-interfaces-output-direction {
        type uint32;
        description
          "Totalinterfaces with service-policy in the
         output direction";
      }
    }  // grouping PLMGR-PMAP-TARGETS-SUMMARY-BG

    grouping POLICY-MAP-DETAILED-SHOW-BG {
      description
        "Policy-map detail show bag";
      container pmap {
        description "Policy map info";
        uses POLICY-MAP-BG;
      }  // container pmap

      container ipv4-acl {
        description "IPv4 Access-list";
        uses STRING-ARRAY;
      }  // container ipv4-acl

      container ipv6-acl {
        description "IPv6 Access-list";
        uses STRING-ARRAY;
      }  // container ipv6-acl

      container ether-service-acl {
        description
          "Ethernet-Services Access-list";
        uses STRING-ARRAY;
      }  // container ether-service-acl
    }  // grouping POLICY-MAP-DETAILED-SHOW-BG

    grouping PLMGR-SUMMARY-BG {
      description "The policymgr database";
      leaf total-class-maps {
        type uint32;
        description
          "Total number of Classmaps configured";
      }

      leaf total-class-map-types {
        type uint32;
        description
          "Total number of Classmap types configured";
      }

      leaf total-policy-maps {
        type uint32;
        description
          "Total number of Policymaps configured";
      }

      leaf total-policy-map-types {
        type uint32;
        description
          "Total number of Policymap types configured";
      }

      list class-maps {
        description
          "Summary of Classmap database";
        uses PLMGR-APP-DB-BG;
      }  // list class-maps

      list policy-maps {
        description
          "Summary of Policymap database";
        uses PLMGR-APP-DB-BG;
      }  // list policy-maps
    }  // grouping PLMGR-SUMMARY-BG

    grouping ACTION-IPV6-NH-INFO-ARRAY {
      description
        "ACTION IPV6 NH INFO ARRAY";
      list action-ipv6-nh-info-array {
        description
          "action ipv6 nh info array";
        uses ACTION-IPV6-NH-INFO-ST;
      }  // list action-ipv6-nh-info-array
    }  // grouping ACTION-IPV6-NH-INFO-ARRAY

    grouping ACTION-PREPAID-CONFIG-INFO-P {
      description
        "ACTION PREPAID CONFIG INFO P";
      uses ACTION-PREPAID-CFG-ST;
    }  // grouping ACTION-PREPAID-CONFIG-INFO-P

    grouping PCLASS-KEY-HD {
      description "PCLASS KEY HD";
      uses POLICY-CLASS-INFO-KEY-BG;
    }  // grouping PCLASS-KEY-HD

    grouping CLASS-MATCH-INFO-ST {
      description "Class-map match info";
      list class-match-info-st {
        description "class match info st";
        container match-data {
          description "Match criteria";
          uses CLASS-MATCH-DATA-UN;
        }  // container match-data

        leaf flags {
          type uint32;
          description "Flags";
        }
      }  // list class-match-info-st
    }  // grouping CLASS-MATCH-INFO-ST

    grouping ACTION-CAC-INFO {
      description "ACTION CAC INFO";
      list action-cac-info-st {
        description "action cac info st";
        uses ACTION-CAC-INFO-ST;
      }  // list action-cac-info-st
    }  // grouping ACTION-CAC-INFO

    grouping ACTION-CAC-INFO-ST {
      description "CAC action info bag";
      container flow-rate {
        description "flow rate";
        uses POLICY-PARAM-UINT32-ST;
      }  // container flow-rate

      container rate {
        description "rate";
        uses POLICY-PARAM-UINT32-ST;
      }  // container rate

      leaf cac-type {
        type Cac-flow-actn-type-e;
        description "cac type";
      }

      leaf idle-timeout {
        type uint16;
        description "idle timeout";
      }
    }  // grouping ACTION-CAC-INFO-ST

    grouping AFMON-RTP-CLOCK-RATE-ST {
      description
        "AFMon RTP clock rate params";
      leaf pt {
        type uint32;
        description "pt";
      }

      leaf frequency {
        type uint32;
        description "frequency";
      }
    }  // grouping AFMON-RTP-CLOCK-RATE-ST

    grouping ACTION-ACCT-AAA-LIST-INFO-P {
      description
        "ACTION ACCT AAA LIST INFO P";
      uses ACTION-ACCT-AAA-LIST-ST;
    }  // grouping ACTION-ACCT-AAA-LIST-INFO-P

    grouping PLMGR-APP-TB-PERSISTENT-CAP-T {
      description
        "Table persistent capability";
      leaf persistent {
        type boolean;
        description
          "Table persistent support";
      }
    }  // grouping PLMGR-APP-TB-PERSISTENT-CAP-T

    grouping ACTION-BWREM-INFO-P {
      description "ACTION BWREM INFO P";
      uses ACTION-BWREM-INFO-ST;
    }  // grouping ACTION-BWREM-INFO-P

    grouping PLMGR-APP-TB-TRANSIENT-CAP-T {
      description
        "Table transient support capability";
      leaf transient {
        type boolean;
        description
          "Table transient support";
      }
    }  // grouping PLMGR-APP-TB-TRANSIENT-CAP-T

    grouping PCLASS-DATA-HD {
      description "PCLASS DATA HD";
      uses POLICY-CLASS-INFO-BG;
    }  // grouping PCLASS-DATA-HD

    grouping PLMGR-OBJ-REF-PMAP-BG {
      description "Object detail.";
      leaf total-internal-reference-objects {
        type uint32;
        description
          "Total number of internal reference objects";
      }

      leaf total-class-maps {
        type uint32;
        description
          "Total number of Classmaps in a Policymap";
      }

      leaf total-flows {
        type uint32;
        description
          "Total flows in a Policymap";
      }
    }  // grouping PLMGR-OBJ-REF-PMAP-BG

    grouping PLMGR-VAR-VAL-UN {
      description
        "Union of default values corrosponding to variable
       type";
      leaf type {
        type Plmgr-var-type-en;
        description "type";
      }

      leaf class-name {
        when
          "../type = 'plmgr-var-type-class-name'" {
          description
            "../type = 'PLMGR_VAR_TYPE_CLASS_NAME'";
        }
        type Class-map-name;
        description "class name";
      }

      leaf uint8_val {
        when
          "../type = 'plmgr-var-type-uint8'" {
          description
            "../type = 'PLMGR_VAR_TYPE_UINT8'";
        }
        type uint8;
        description "uint8 val";
      }

      leaf uint16_val {
        when
          "../type = 'plmgr-var-type-uint16'" {
          description
            "../type = 'PLMGR_VAR_TYPE_UINT16'";
        }
        type uint16;
        description "uint16 val";
      }

      leaf uint32_val {
        when
          "../type = 'plmgr-var-type-uint32'" {
          description
            "../type = 'PLMGR_VAR_TYPE_UINT32'";
        }
        type uint32;
        description "uint32 val";
      }

      leaf param-uint32-val {
        when
          "../type = 'plmgr-var-type-param-uint32'" {
          description
            "../type = 'PLMGR_VAR_TYPE_PARAM_UINT32'";
        }
        type uint32;
        description "param uint32 val";
      }

      leaf dscp-val {
        when
          "../type = 'plmgr-var-type-dscp'" {
          description
            "../type = 'PLMGR_VAR_TYPE_DSCP'";
        }
        type uint8;
        description "dscp val";
      }

      leaf prec-val {
        when
          "../type = 'plmgr-var-type-prec'" {
          description
            "../type = 'PLMGR_VAR_TYPE_PREC'";
        }
        type uint8;
        description "prec val";
      }
    }  // grouping PLMGR-VAR-VAL-UN

    grouping ACTION-AUTHORIZE-ID-ST {
      description "authorize identifiers";
      leaf id {
        type uint8;
        description "id";
      }

      leaf aaa-list-name {
        type string;
        description "aaa list name";
      }

      leaf format-name {
        type string;
        description "format name";
      }

      leaf password {
        type string;
        description "password";
      }
    }  // grouping ACTION-AUTHORIZE-ID-ST

    grouping ACTION-ENCAP-INFO-ST {
      description
        "Encapsulation sequence action";
      leaf seq {
        type uint8;
        description "seq";
      }
    }  // grouping ACTION-ENCAP-INFO-ST

    grouping IPV4-ADDR-ARRAY {
      description "IPV4 ADDR ARRAY";
      list ipv4-addr-array {
        description "ipv4 addr array";
        uses MATCH-IPV4-ST;
      }  // list ipv4-addr-array
    }  // grouping IPV4-ADDR-ARRAY

    grouping NAS-PORT-ARRAY {
      description "NAS PORT ARRAY";
      list nas-port-array {
        description "nas port array";
        uses MATCH-NAS-PORT-ST;
      }  // list nas-port-array
    }  // grouping NAS-PORT-ARRAY

    grouping ACTION-AFMON-IPCBR-INFO-ST {
      description
        "AFMon IP-CBR Configuration";
      container ip-bit-rate {
        description "data rate in bps";
        uses POLICY-PARAM-UINT32-ST;
      }  // container ip-bit-rate

      container media-bit-rate {
        description "media data rate in bps";
        uses POLICY-PARAM-UINT32-ST;
      }  // container media-bit-rate

      leaf action-metric-type {
        type Policy-action-en;
        description "metric type";
      }

      leaf ip-pkt-rate {
        type uint32;
        description "packet rate in pps";
      }

      leaf media-pkt-size {
        type uint32;
        units "byte";
        description
          "media packet size in bytes";
      }

      leaf media-pkts-per-ip {
        type uint32;
        description
          "media packets per ip pkt";
      }
    }  // grouping ACTION-AFMON-IPCBR-INFO-ST

    grouping ACTION-AFMON-IPCBR-INFO-P {
      description
        "ACTION AFMON IPCBR INFO P";
      uses ACTION-AFMON-IPCBR-INFO-ST;
    }  // grouping ACTION-AFMON-IPCBR-INFO-P

    grouping ACTION-IPV4-NH-INFO-ARRAY {
      description
        "ACTION IPV4 NH INFO ARRAY";
      list action-ipv4-nh-info-array {
        description
          "action ipv4 nh info array";
        uses ACTION-IPV4-NH-INFO-ST;
      }  // list action-ipv4-nh-info-array
    }  // grouping ACTION-IPV4-NH-INFO-ARRAY

    grouping PEVENT-DATA-HD {
      description "PEVENT DATA HD";
      uses POLICY-EVENT-INFO-BG;
    }  // grouping PEVENT-DATA-HD

    grouping ACTION-REDIRECT-INFO-ST {
      description "redirect action";
      leaf value {
        type uint32;
        description "value";
      }

      leaf type {
        type Redirect-type-e;
        description "type";
      }
    }  // grouping ACTION-REDIRECT-INFO-ST

    grouping CLASS-MAP-BG {
      description "Class-map bag";
      list class-map-bg {
        description "class map bg";
        container match-infop {
          description
            "Pointer to the first Match info";
          uses CLASS-MATCH-INFO-ST;
        }  // container match-infop

        leaf name {
          type Class-map-name;
          description
            "Name of the class-map";
        }

        leaf type {
          type Class-map-type-en;
          description
            "Class-Map Type QoS/PBR/Netflow/...";
        }

        leaf mode {
          type Class-map-mode-en;
          description
            "Class-Map Mode Match any/Match all";
        }

        leaf description {
          type string;
          description "description";
        }
      }  // list class-map-bg
    }  // grouping CLASS-MAP-BG

    grouping MATCH-IPV6-ST {
      description "MATCH IPV6 ST";
      leaf prefix {
        type inet:ipv6-address;
        description "IPV6 prefix";
      }

      leaf mask {
        type uint32;
        description "IPV6 mask";
      }
    }  // grouping MATCH-IPV6-ST

    grouping ACTION-SERVICE-POLICY-INFO-ST {
      description
        "ACTION SERVICE POLICY INFO ST";
      uses CHLD-POL-ENC-UN;
    }  // grouping ACTION-SERVICE-POLICY-INFO-ST

    grouping ACTION-ENCAP-INFO-P {
      description "ACTION ENCAP INFO P";
      uses ACTION-ENCAP-INFO-ST;
    }  // grouping ACTION-ENCAP-INFO-P

    grouping ACTION-PBF-INFO-ARRAY {
      description "ACTION PBF INFO ARRAY";
      list action-pbf-info-array {
        description "action pbf info array";
        uses ACTION-PBF-INFO-ST;
      }  // list action-pbf-info-array
    }  // grouping ACTION-PBF-INFO-ARRAY

    grouping ACTION-HTTPR-INFO-ST {
      description "httpr action";
      leaf redirect-url {
        type string;
        description "redirect url";
      }
    }  // grouping ACTION-HTTPR-INFO-ST

    grouping POLICY-ACTION-DATAP-UN {
      description
        "Pointers to the action data of different type";
      container mark {
        when
          "../type = 'policy-action-mark'" {
          description
            "../type = 'POLICY_ACTION_MARK'";
        }
        description "mark";
        uses ACTION-MARK-INFO;
      }  // container mark

      container mark2 {
        when
          "../type = 'policy-action-mark2'" {
          description
            "../type = 'POLICY_ACTION_MARK2'";
        }
        description "mark2";
        uses ACTION-MARK2-INFO;
      }  // container mark2

      container wred {
        when
          "../type = 'policy-action-wred'" {
          description
            "../type = 'POLICY_ACTION_WRED'";
        }
        description "wred";
        uses ACTION-WRED-INFO;
      }  // container wred

      container encap {
        when
          "../type = 'policy-action-encap-seq'" {
          description
            "../type = 'POLICY_ACTION_ENCAP_SEQ'";
        }
        description "encap";
        uses ACTION-ENCAP-INFO-ST;
      }  // container encap

      container prio {
        when
          "../type = 'policy-action-priority'" {
          description
            "../type = 'POLICY_ACTION_PRIORITY'";
        }
        description "prio";
        uses ACTION-PRIO-INFO-ST;
      }  // container prio

      container bwrem {
        when
          "../type = 'policy-action-bw-remaining'" {
          description
            "../type = 'POLICY_ACTION_BW_REMAINING'";
        }
        description "bwrem";
        uses ACTION-BWREM-INFO-ST;
      }  // container bwrem

      container min-bw {
        when
          "../type = 'policy-action-min-bw'" {
          description
            "../type = 'POLICY_ACTION_MIN_BW'";
        }
        description "min bw";
        uses ACTION-MINBW-INFO-ST;
      }  // container min-bw

      container authen-aaa {
        when
          "../type = 'policy-action-authenticate-aaa'" {
          description
            "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
        }
        description "authen aaa";
        uses ACTION-AUTHEN-AAA-ST;
      }  // container authen-aaa

      container collect-id {
        when
          "../type = 'policy-action-collect-id'" {
          description
            "../type = 'POLICY_ACTION_COLLECT_ID'";
        }
        description "collect id";
        uses ACTION-COLLECT-ID-ST;
      }  // container collect-id

      container decode-id {
        when
          "../type = 'policy-action-decode-identifier'" {
          description
            "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
        }
        description "decode id";
        uses ACTION-DECODE-IDENTIFIER-ST;
      }  // container decode-id

      container set-timer {
        when
          "../type = 'policy-action-set-timer'" {
          description
            "../type = 'POLICY_ACTION_SET_TIMER'";
        }
        description "set timer";
        uses ACTION-SET-TIMER-ST;
      }  // container set-timer

      container stop-timer {
        when
          "../type = 'policy-action-stop-timer'" {
          description
            "../type = 'POLICY_ACTION_STOP_TIMER'";
        }
        description "stop timer";
        uses ACTION-STOP-TIMER-ST;
      }  // container stop-timer

      container acct-aaa-list {
        when
          "../type = 'policy-action-accounting-aaa-list'" {
          description
            "../type = 'POLICY_ACTION_ACCOUNTING_AAA_LIST'";
        }
        description "acct aaa list";
        uses ACTION-ACCT-AAA-LIST-ST;
      }  // container acct-aaa-list

      container query-ancp {
        when
          "../type = 'policy-action-query-ancp'" {
          description
            "../type = 'POLICY_ACTION_QUERY_ANCP'";
        }
        description "query ancp";
        uses ACTION-QUERY-ANCP-SESSION-ST;
      }  // container query-ancp

      container prepaid-cfg {
        when
          "../type = 'policy-action-prepaid-config'" {
          description
            "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
        }
        description "prepaid cfg";
        uses ACTION-PREPAID-CFG-ST;
      }  // container prepaid-cfg

      container timeout-idle {
        when
          "../type = 'policy-action-timeout-idle'" {
          description
            "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
        }
        description "timeout idle";
        uses ACTION-TIMEOUT-IDLE-ST;
      }  // container timeout-idle

      container proxy-aaa {
        when
          "../type = 'policy-action-proxy-aaa'" {
          description
            "../type = 'POLICY_ACTION_PROXY_AAA'";
        }
        description "proxy aaa";
        uses ACTION-PROXY-AAA-ST;
      }  // container proxy-aaa

      container act-template {
        when
          "../type = 'policy-action-template-activate'" {
          description
            "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
        }
        description "act template";
        uses ACTION-TEMPLATE-ST;
      }  // container act-template

      container deact-template {
        when
          "../type = 'policy-action-template-deactivate'" {
          description
            "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
        }
        description "deact template";
        uses ACTION-TEMPLATE-ST;
      }  // container deact-template

      container qlimit {
        when
          "../type = 'policy-action-q-limit'" {
          description
            "../type = 'POLICY_ACTION_Q_LIMIT'";
        }
        description "qlimit";
        uses ACTION-QLIMIT-INFO-ARRAY;
      }  // container qlimit

      container accounting-event-aaa {
        when
          "../type = 'policy-action-accounting-event-aaa-list'" {
          description
            "../type =
           'POLICY_ACTION_ACCOUNTING_EVENT_AAA_LIST'";
        }
        description "accounting event aaa";
        uses ACTION-ACCOUNTING-EVENT-ST;
      }  // container accounting-event-aaa

      container authorize-id {
        when
          "../type = 'policy-action-authorize-id'" {
          description
            "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
        }
        description "authorize id";
        uses ACTION-AUTHORIZE-ID-ST;
      }  // container authorize-id

      container afm-react {
        when
          "../type = 'policy-action-afmon-react'" {
          description
            "../type = 'POLICY_ACTION_AFMON_REACT'";
        }
        description "afm react";
        uses ACTION-AFMON-REACT-INFO;
      }  // container afm-react

      container httpr {
        when
          "../type = 'policy-action-httpr'" {
          description
            "../type = 'POLICY_ACTION_HTTPR'";
        }
        description "httpr";
        uses ACTION-HTTPR-INFO-ST;
      }  // container httpr

      container punt {
        when
          "../type = 'policy-action-punt'" {
          description
            "../type = 'POLICY_ACTION_PUNT'";
        }
        description "punt";
        uses ACTION-PUNT-INFO-ST;
      }  // container punt

      container copy {
        when
          "../type = 'policy-action-copy'" {
          description
            "../type = 'POLICY_ACTION_COPY'";
        }
        description "copy";
        uses ACTION-COPY-INFO-ST;
      }  // container copy

      container sfrag {
        when
          "../type = 'policy-action-sfrag'" {
          description
            "../type = 'POLICY_ACTION_SFRAG'";
        }
        description "sfrag";
        uses ACTION-SFRAG-INFO-ST;
      }  // container sfrag

      container redirect {
        when
          "../type = 'policy-action-redirect'" {
          description
            "../type = 'POLICY_ACTION_REDIRECT'";
        }
        description "redirect";
        uses ACTION-REDIRECT-INFO-ST;
      }  // container redirect

      container out-intf {
        when
          "../type = 'policy-action-output-interface'" {
          description
            "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
        }
        description "out intf";
        uses ACTION-OUTPUT-INTERFACE-INFO-ST;
      }  // container out-intf

      container serv-func {
        when
          "../type = 'policy-action-service-function-path'" {
          description
            "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
        }
        description "serv func";
        uses ACTION-SERVICE-FUNCTION-PATH-ST;
      }  // container serv-func

      container http-enrich {
        when
          "../type = 'policy-action-http-enrich'" {
          description
            "../type = 'POLICY_ACTION_HTTP_ENRICH'";
        }
        description "http enrich";
      }  // container http-enrich

      container police {
        when
          "../type = 'policy-action-police'" {
          description
            "../type = 'POLICY_ACTION_POLICE'";
        }
        description "police";
        uses ACTION-POLICE-INFO-STR;
      }  // container police

      container shape {
        when
          "../type = 'policy-action-shape'" {
          description
            "../type = 'POLICY_ACTION_SHAPE'";
        }
        description "shape";
        uses ACTION-SHAPE-INFO-STR;
      }  // container shape

      container child-policy {
        when
          "../type = 'policy-action-serv-pol'" {
          description
            "../type = 'POLICY_ACTION_SERV_POL'";
        }
        description "child policy";
        uses CHLD-POL-ENC-UNION;
      }  // container child-policy

      container cac {
        when "../type = 'policy-action-cac'" {
          description
            "../type = 'POLICY_ACTION_CAC'";
        }
        description "cac";
        uses ACTION-CAC-INFO;
      }  // container cac

      container pfc {
        when "../type = 'policy-action-pfc'" {
          description
            "../type = 'POLICY_ACTION_PFC'";
        }
        description "pfc";
        uses ACTION-PFC-INFO;
      }  // container pfc

      container flow-parm {
        when
          "../type = 'policy-action-afmon-flow-parm'" {
          description
            "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
        }
        description "flow parm";
        uses ACTION-AFMON-FLOW-PARM-INFO-ST;
      }  // container flow-parm

      container ipcbr {
        when
          "../type = 'policy-action-afmon-ipcbr-metric'" {
          description
            "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
        }
        description "ipcbr";
        uses ACTION-AFMON-IPCBR-INFO-ST;
      }  // container ipcbr

      container rtp {
        when
          "../type = 'policy-action-afmon-rtp-metric'" {
          description
            "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
        }
        description "rtp";
        uses ACTION-AFMON-RTP-INFO-ST;
      }  // container rtp

      container rtp-mmr {
        when
          "../type = 'policy-action-afmon-rtp-mmr-metric'" {
          description
            "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
        }
        description "rtp mmr";
        uses ACTION-AFMON-RTP-INFO-ST;
      }  // container rtp-mmr

      container rtp-j2k {
        when
          "../type = 'policy-action-afmon-rtp-j2k-metric'" {
          description
            "../type = 'POLICY_ACTION_AFMON_RTP_J2K_METRIC'";
        }
        description "rtp j2k";
        uses ACTION-AFMON-RTP-INFO-ST;
      }  // container rtp-j2k

      container rtp-voice {
        when
          "../type = 'policy-action-afmon-rtp-voice-metric'" {
          description
            "../type =
           'POLICY_ACTION_AFMON_RTP_VOICE_METRIC'";
        }
        description "rtp voice";
        uses ACTION-AFMON-RTP-INFO-ST;
      }  // container rtp-voice

      container mdi {
        when
          "../type = 'policy-action-afmon-mdi-metric'" {
          description
            "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
        }
        description "mdi";
        uses ACTION-AFMON-MDI-INFO-ST;
      }  // container mdi

      container mdi-rtp {
        when
          "../type = 'policy-action-afmon-mdi-rtp-metric'" {
          description
            "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
        }
        description "mdi rtp";
        uses ACTION-AFMON-MDI-INFO-ST;
      }  // container mdi-rtp

      container fmm {
        when
          "../type = 'policy-action-afmon-fmm'" {
          description
            "../type = 'POLICY_ACTION_AFMON_FMM'";
        }
        description "fmm";
        uses ACTION-AFMON-FMM-INFO-ST;
      }  // container fmm

      container pbf {
        when
          "../type = 'policy-action-pbr-next-hop'" {
          description
            "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
        }
        description "pbf";
        uses ACTION-PBF-INFO-ARRAY;
      }  // container pbf

      container ipv4-nh {
        when
          "../type = 'policy-action-ipv4-nh'" {
          description
            "../type = 'POLICY_ACTION_IPV4_NH'";
        }
        description "ipv4 nh";
        uses ACTION-IPV4-NH-INFO-ARRAY;
      }  // container ipv4-nh

      container ipv6-nh {
        when
          "../type = 'policy-action-ipv6-nh'" {
          description
            "../type = 'POLICY_ACTION_IPV6_NH'";
        }
        description "ipv6 nh";
        uses ACTION-IPV6-NH-INFO-ARRAY;
      }  // container ipv6-nh

      leaf type {
        type Policy-action-en;
        description "type";
      }

      leaf data-p {
        when
          "../type != 'policy-action-mark' and ../type != 'policy-action-mark2' and ../type != 'policy-action-wred' and ../type != 'policy-action-encap-seq' and ../type != 'policy-action-priority' and ../type != 'policy-action-bw-remaining' and ../type != 'policy-action-min-bw' and ../type != 'policy-action-authenticate-aaa' and ../type != 'policy-action-collect-id' and ../type != 'policy-action-decode-identifier' and ../type != 'policy-action-set-timer' and ../type != 'policy-action-stop-timer' and ../type != 'policy-action-accounting-aaa-list' and ../type != 'policy-action-query-ancp' and ../type != 'policy-action-prepaid-config' and ../type != 'policy-action-timeout-idle' and ../type != 'policy-action-proxy-aaa' and ../type != 'policy-action-template-activate' and ../type != 'policy-action-template-deactivate' and ../type != 'policy-action-q-limit' and ../type != 'policy-action-accounting-event-aaa-list' and ../type != 'policy-action-authorize-id' and ../type != 'policy-action-afmon-react' and ../type != 'policy-action-httpr' and ../type != 'policy-action-punt' and ../type != 'policy-action-copy' and ../type != 'policy-action-sfrag' and ../type != 'policy-action-redirect' and ../type != 'policy-action-output-interface' and ../type != 'policy-action-service-function-path' and ../type != 'policy-action-police' and ../type != 'policy-action-shape' and ../type != 'policy-action-serv-pol' and ../type != 'policy-action-cac' and ../type != 'policy-action-pfc' and ../type != 'policy-action-afmon-flow-parm' and ../type != 'policy-action-afmon-ipcbr-metric' and ../type != 'policy-action-afmon-rtp-metric' and ../type != 'policy-action-afmon-rtp-mmr-metric' and ../type != 'policy-action-afmon-rtp-j2k-metric' and ../type != 'policy-action-afmon-rtp-voice-metric' and ../type != 'policy-action-afmon-mdi-metric' and ../type != 'policy-action-afmon-mdi-rtp-metric' and ../type != 'policy-action-afmon-fmm' and ../type != 'policy-action-pbr-next-hop' and ../type != 'policy-action-ipv4-nh' and ../type != 'policy-action-ipv6-nh'" {
          description
            "../type != 'POLICY_ACTION_MARK' and ../type !=
           'POLICY_ACTION_MARK2' and ../type !=
           'POLICY_ACTION_WRED' and ../type !=
           'POLICY_ACTION_ENCAP_SEQ' and ../type !=
           'POLICY_ACTION_PRIORITY' and ../type !=
           'POLICY_ACTION_BW_REMAINING' and ../type !=
           'POLICY_ACTION_MIN_BW' and ../type !=
           'POLICY_ACTION_AUTHENTICATE_AAA' and ../type
           != 'POLICY_ACTION_COLLECT_ID' and ../type !=
           'POLICY_ACTION_DECODE_IDENTIFIER' and ../type
           != 'POLICY_ACTION_SET_TIMER' and ../type !=
           'POLICY_ACTION_STOP_TIMER' and ../type !=
           'POLICY_ACTION_ACCOUNTING_AAA_LIST' and .
           ./type != 'POLICY_ACTION_QUERY_ANCP' and .
           ./type != 'POLICY_ACTION_PREPAID_CONFIG' and .
           ./type != 'POLICY_ACTION_TIMEOUT_IDLE' and .
           ./type != 'POLICY_ACTION_PROXY_AAA' and .
           ./type != 'POLICY_ACTION_TEMPLATE_ACTIVATE'
           and ../type !=
           'POLICY_ACTION_TEMPLATE_DEACTIVATE' and .
           ./type != 'POLICY_ACTION_Q_LIMIT' and ../type
           != 'POLICY_ACTION_ACCOUNTING_EVENT_AAA_LIST'
           and ../type != 'POLICY_ACTION_AUTHORIZE_ID'
           and ../type != 'POLICY_ACTION_AFMON_REACT' and
           ../type != 'POLICY_ACTION_HTTPR' and ../type
           != 'POLICY_ACTION_PUNT' and ../type !=
           'POLICY_ACTION_COPY' and ../type !=
           'POLICY_ACTION_SFRAG' and ../type !=
           'POLICY_ACTION_REDIRECT' and ../type !=
           'POLICY_ACTION_OUTPUT_INTERFACE' and ../type
           != 'POLICY_ACTION_SERVICE_FUNCTION_PATH' and .
           ./type != 'POLICY_ACTION_POLICE' and ../type
           != 'POLICY_ACTION_SHAPE' and ../type !=
           'POLICY_ACTION_SERV_POL' and ../type !=
           'POLICY_ACTION_CAC' and ../type !=
           'POLICY_ACTION_PFC' and ../type !=
           'POLICY_ACTION_AFMON_FLOW_PARM' and ../type !=
           'POLICY_ACTION_AFMON_IPCBR_METRIC' and ../type
           != 'POLICY_ACTION_AFMON_RTP_METRIC' and .
           ./type != 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'
           and ../type !=
           'POLICY_ACTION_AFMON_RTP_J2K_METRIC' and .
           ./type !=
           'POLICY_ACTION_AFMON_RTP_VOICE_METRIC' and .
           ./type != 'POLICY_ACTION_AFMON_MDI_METRIC' and
           ../type !=
           'POLICY_ACTION_AFMON_MDI_RTP_METRIC' and .
           ./type != 'POLICY_ACTION_AFMON_FMM' and .
           ./type != 'POLICY_ACTION_PBR_NEXTHOP' and .
           ./type != 'POLICY_ACTION_IPV4_NH' and ../type
           != 'POLICY_ACTION_IPV6_NH'";
        }
        type uint32;
        description "data p";
      }
    }  // grouping POLICY-ACTION-DATAP-UN

    grouping ACTION-DECODE-IDENTIFIER-ST {
      description
        "ACTION DECODE IDENTIFIER ST";
      leaf id {
        type Decode-identifier-en;
        description "id";
      }

      leaf format-name {
        type string;
        description "format name";
      }
    }  // grouping ACTION-DECODE-IDENTIFIER-ST

    grouping ACTION-POLICE-INFO-STR {
      description "ACTION POLICE INFO ARRAY";
      list action-police-info-st {
        description
          "action police info array";
        uses ACTION-POLICE-INFO-ST;
      }  // list action-police-info-st
    }  // grouping ACTION-POLICE-INFO-STR

    grouping ACTION-POLICE-INFO-ST {
      description "Police action info bag";
      container rate {
        description "rate";
        uses POLICY-PARAM-UINT32-ST;
      }  // container rate

      container burst {
        description "burst";
        uses POLICY-PARAM-UINT32-ST;
      }  // container burst

      container peak-rate {
        description "peak rate";
        uses POLICY-PARAM-UINT32-ST;
      }  // container peak-rate

      container peak-burst {
        description "peak burst";
        uses POLICY-PARAM-UINT32-ST;
      }  // container peak-burst

      container cdvt {
        description "cdvt";
        uses POLICY-PARAM-UINT32-ST;
      }  // container cdvt

      container conform-actns {
        description "conform actns";
        uses POLICE-ACTION-ARRAY;
      }  // container conform-actns

      container exceed-actns {
        description "exceed actns";
        uses POLICE-ACTION-ARRAY;
      }  // container exceed-actns

      container violate-actns {
        description "violate actns";
        uses POLICE-ACTION-ARRAY;
      }  // container violate-actns

      container confclass-p {
        description "confclass p";
        uses CLASS-MAP-BG;
      }  // container confclass-p

      container excdclass-p {
        description "excdclass p";
        uses CLASS-MAP-BG;
      }  // container excdclass-p

      leaf flags {
        type uint32;
        description "flags";
      }

      leaf police-flags {
        type uint32;
        description "police flags";
      }

      leaf sbuck-name {
        type Shared-bucket-name;
        description "sbuck name";
      }

      leaf sbuck-type {
        type Shared-bucket-type;
        description "sbuck type";
      }
    }  // grouping ACTION-POLICE-INFO-ST

    grouping PLMGR-APP-GL-BULK-BEST-EFFORT-CAP-T {
      description
        " Best effort capability of a network element";
      leaf best-effort-per-bulk-instance {
        type boolean;
        description
          "Specifies policymgr supports bulk configuration
         best effort behavior or not";
      }
    }  // grouping PLMGR-APP-GL-BULK-BEST-EFFORT-CAP-T

    grouping POLICY-CLASS-INFO-KEY-BG {
      description "Policy-class key Bag";
      list policy-class-info-key-bg {
        description
          "policy class info key bg";
        leaf policy-class-hd {
          type uint32;
          description "policy class hd";
        }

        leaf seq {
          type uint32;
          description "seq";
        }
      }  // list policy-class-info-key-bg
    }  // grouping POLICY-CLASS-INFO-KEY-BG

    grouping ACTION-COLLECT-ID-INFO-P {
      description "ACTION COLLECT ID INFO P";
      uses ACTION-COLLECT-ID-ST;
    }  // grouping ACTION-COLLECT-ID-INFO-P

    grouping POLICY-CLASS-INFO-UN {
      description "POLICY CLASS INFO UN";
      container key {
        when
          "../type = 'policy-class-info-key-type'" {
          description
            "../type = 'POLICY_CLASS_INFO_KEY_TYPE'";
        }
        description "key";
        uses POLICY-CLASS-INFO-KEY-BG;
      }  // container key

      container mod-data {
        when
          "../type = 'policy-class-info-mod-type'" {
          description
            "../type = 'POLICY_CLASS_INFO_MOD_TYPE'";
        }
        description "mod data";
        uses POLICY-CLASS-INFO-MOD-BG;
      }  // container mod-data

      leaf type {
        type Policy-class-info-en;
        description "type";
      }
    }  // grouping POLICY-CLASS-INFO-UN

    grouping ACTION-PRIO-INFO-P {
      description "ACTION PRIO INFO P";
      uses ACTION-PRIO-INFO-ST;
    }  // grouping ACTION-PRIO-INFO-P

    grouping ACTION-QUERY-ANCP-SESSION-P {
      description
        "ACTION QUERY ANCP SESSION P";
      uses ACTION-QUERY-ANCP-SESSION-ST;
    }  // grouping ACTION-QUERY-ANCP-SESSION-P

    grouping PLMGR-TABLE-CAP-BG {
      description
        "Table Capability details ";
      list table-capabilty {
        description "Table capability";
        uses PLMGR-APP-TB-CAPS-T;
      }  // list table-capabilty
    }  // grouping PLMGR-TABLE-CAP-BG

    grouping POLICE-ACTION-UN {
      description "Police action bag";
      container mark {
        when
          "../type = 'police-action-mark'" {
          description
            "../type = 'POLICE_ACTION_MARK'";
        }
        description "mark";
        uses ACTION-MARK-INFO-ST;
      }  // container mark

      leaf type {
        type Police-action-type-en;
        description "type";
      }
    }  // grouping POLICE-ACTION-UN

    grouping UINT32-RNG-ST {
      description "UINT32 RNG ST";
      leaf min {
        type uint32;
        description
          "Lower limit of the range";
      }

      leaf max {
        type uint32;
        description
          "Upper limit of the range";
      }
    }  // grouping UINT32-RNG-ST

    grouping ACTION-COLLECT-ID-ST {
      description "Collect identifiers";
      leaf id {
        type Identifier-en;
        description "id";
      }

      leaf aaa-list-name {
        type string;
        description "aaa list name";
      }
    }  // grouping ACTION-COLLECT-ID-ST

    grouping ACTION-SHAPE-INFO-P {
      description "ACTION SHAPE INFO P";
      uses ACTION-SHAPE-INFO-ST;
    }  // grouping ACTION-SHAPE-INFO-P

    grouping PLMGR-PMAP-DIFF-BG {
      description "Policy-map diff Bag";
      container del {
        description "del";
        uses POLICY-MAP-BG;
      }  // container del

      container add {
        description "add";
        uses POLICY-MAP-BG;
      }  // container add
    }  // grouping PLMGR-PMAP-DIFF-BG

    grouping ACTION-WRED-INFO-P {
      description "ACTION WRED INFO P";
      uses ACTION-WRED-INFO;
    }  // grouping ACTION-WRED-INFO-P

    grouping PLMGR-APP-GL-STATS-CAP-T {
      description
        "Stats capability of a network element";
      leaf maximum-class-stats-polling-rate {
        type uint32;
        description
          "Maximum statistics polling rate supported by a
         network in terms of class stats per sec";
      }
    }  // grouping PLMGR-APP-GL-STATS-CAP-T

    grouping UINT32-ARRAY {
      description "UINT32 ARRAY";
      leaf-list uint32_array {
        type uint32;
        description "uint32 array";
      }
    }  // grouping UINT32-ARRAY

    grouping PLMGR-OBJ-REF-SUMMARY-BG {
      description "Object detail.";
      leaf object-name {
        type string {
          length "0..64";
        }
        description
          "Name of object (Policymap/Classmap)";
      }
    }  // grouping PLMGR-OBJ-REF-SUMMARY-BG

    grouping ACTION-COPY-INFO-ST {
      description "copy action";
      leaf num-byte {
        type uint32;
        units "byte";
        description "number of bytes";
      }

      leaf sn-type {
        type Dpss-snid-type-en;
        description "service node ID type";
      }

      leaf sn-index {
        type uint32;
        description "service node index";
      }

      leaf sn-name {
        type string;
        description "service node url";
      }

      leaf app-id {
        type uint32;
        description "application ID";
      }

      leaf local-id {
        type uint32;
        description "local ID";
      }

      leaf vsnode-type {
        type Vsvc-service-type-t;
        description "vservice node type";
      }
    }  // grouping ACTION-COPY-INFO-ST

    grouping ACTION-SFRAG-INFO-P {
      description "ACTION SFRAG INFO P";
      uses ACTION-SFRAG-INFO-ST;
    }  // grouping ACTION-SFRAG-INFO-P

    grouping PLMGR-APP-TB-CLASS-CAP-T {
      description " Table class capability";
      leaf classmap-class-support {
        type boolean;
        description "ClassmapClassSupport";
      }

      leaf class-sequence-number-support {
        type boolean;
        description
          "ClassSequenceNumberSupport";
      }

      leaf class-ordering-support {
        type boolean;
        description "ClassOrderingSupport";
      }

      leaf class-idel-timeout-support {
        type boolean;
        description
          "ClassIdelTimeoutSupport";
      }

      leaf inline-c-lass-support {
        type boolean;
        description "InlineCLassSupport";
      }

      leaf maximum-inline-class-provision-rate {
        type uint32;
        description
          "MaximumInlineClassProvisionRate";
      }

      leaf maximum-inline-class-per-table {
        type uint32;
        description
          "MaximumInlineClassPerTable";
      }
    }  // grouping PLMGR-APP-TB-CLASS-CAP-T

    grouping PLMGR-PMAP-TARGETS-ARR-BG {
      description "The array bag";
      list plmgr-pmap-targets {
        description "plmgr pmap targets";
        uses PLMGR-PMAP-TARGETS-BG;
      }  // list plmgr-pmap-targets
    }  // grouping PLMGR-PMAP-TARGETS-ARR-BG

    grouping CLASS-MATCH-DATA-UN {
      description
        "Union of pointers to the supported match criteria";
      container ipv4-dscp {
        when
          "../type = 'match-type-ipv4-dscp'" {
          description
            "../type = 'MATCH_TYPE_IPV4_DSCP'";
        }
        description "IPv4 DSCP";
        uses UINT8-RNG-ARRAY;
      }  // container ipv4-dscp

      container ipv6-dscp {
        when
          "../type = 'match-type-ipv6-dscp'" {
          description
            "../type = 'MATCH_TYPE_IPV6_DSCP'";
        }
        description "IPv6 DSCP";
        uses UINT8-RNG-ARRAY;
      }  // container ipv6-dscp

      container dscp {
        when "../type = 'match-type-dscp'" {
          description
            "../type = 'MATCH_TYPE_DSCP'";
        }
        description "Match DSCP range array";
        uses UINT8-RNG-ARRAY;
      }  // container dscp

      container ipv4-prec {
        when
          "../type = 'match-type-ipv4-prec'" {
          description
            "../type = 'MATCH_TYPE_IPV4_PREC'";
        }
        description "IPv4 Precedence";
        uses UINT8-ARRAY;
      }  // container ipv4-prec

      container ipv6-prec {
        when
          "../type = 'match-type-ipv6-prec'" {
          description
            "../type = 'MATCH_TYPE_IPV6_PREC'";
        }
        description "IPv6 Precedence";
        uses UINT8-ARRAY;
      }  // container ipv6-prec

      container prec {
        when "../type = 'match-type-prec'" {
          description
            "../type = 'MATCH_TYPE_PREC'";
        }
        description "Match Precedence array";
        uses UINT8-ARRAY;
      }  // container prec

      container discard-class {
        when
          "../type = 'match-type-disc-cls'" {
          description
            "../type = 'MATCH_TYPE_DISC_CLS'";
        }
        description
          "Match Discard Class array";
        uses UINT8-ARRAY;
      }  // container discard-class

      container qos-group {
        when
          "../type = 'match-type-qos-grp'" {
          description
            "../type = 'MATCH_TYPE_QOS_GRP'";
        }
        description "Match QoS group array";
        uses UINT16-RNG-ARRAY;
      }  // container qos-group

      container traffic-class {
        when
          "../type = 'match-type-traffic-class'" {
          description
            "../type = 'MATCH_TYPE_TRAFFIC_CLASS'";
        }
        description
          "Match Traffic class array";
        uses UINT8-RNG-ARRAY;
      }  // container traffic-class

      container proto {
        when "../type = 'match-type-proto'" {
          description
            "../type = 'MATCH_TYPE_PROTO'";
        }
        description "Match Protocol array";
        uses UINT16-RNG-ARRAY;
      }  // container proto

      container ipv4-packet-len {
        when
          "../type = 'match-type-ipv4-packet-length'" {
          description
            "../type = 'MATCH_TYPE_IPV4_PACKET_LENGTH'";
        }
        description
          "IPv4 packet length array";
        uses UINT16-RNG-ARRAY;
      }  // container ipv4-packet-len

      container ipv6-packet-len {
        when
          "../type = 'match-type-ipv6-packet-length'" {
          description
            "../type = 'MATCH_TYPE_IPV6_PACKET_LENGTH'";
        }
        description
          "IPv6 packet length array";
        uses UINT16-RNG-ARRAY;
      }  // container ipv6-packet-len

      container packet-len {
        when
          "../type = 'match-type-packet-length'" {
          description
            "../type = 'MATCH_TYPE_PACKET_LENGTH'";
        }
        description
          "Match packet length array";
        uses UINT16-RNG-ARRAY;
      }  // container packet-len

      container flow-tag {
        when
          "../type = 'match-type-flow-tag'" {
          description
            "../type = 'MATCH_TYPE_FLOW_TAG'";
        }
        description "Match flow-tag array";
        uses UINT8-RNG-ARRAY;
      }  // container flow-tag

      container tcp-flag {
        when
          "../type = 'match-type-tcp-flag'" {
          description
            "../type = 'MATCH_TYPE_TCP_FLAG'";
        }
        description "Match tcp flag value";
        uses TCP-FLAG-ST;
      }  // container tcp-flag

      container icmpv4-type {
        when
          "../type = 'match-type-icmpv4-type'" {
          description
            "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
        }
        description "Match ipv4 icmp type";
        uses UINT8-RNG-ARRAY;
      }  // container icmpv4-type

      container icmpv4-code {
        when
          "../type = 'match-type-icmpv4-code'" {
          description
            "../type = 'MATCH_TYPE_ICMPV4_CODE'";
        }
        description "Match ipv4 icmp code";
        uses UINT8-RNG-ARRAY;
      }  // container icmpv4-code

      container icmpv6-type {
        when
          "../type = 'match-type-icmpv6-type'" {
          description
            "../type = 'MATCH_TYPE_ICMPV6_TYPE'";
        }
        description "Match ipv6 icmp type";
        uses UINT8-RNG-ARRAY;
      }  // container icmpv6-type

      container icmpv6-code {
        when
          "../type = 'match-type-icmpv6-code'" {
          description
            "../type = 'MATCH_TYPE_ICMPV6_CODE'";
        }
        description "Match ipv6 icmp code";
        uses UINT8-RNG-ARRAY;
      }  // container icmpv6-code

      container mpls-exp {
        when
          "../type = 'match-type-mpls-exp-top'" {
          description
            "../type = 'MATCH_TYPE_MPLS_EXP_TOP'";
        }
        description
          "Match MPLS experimental topmost array";
        uses UINT8-ARRAY;
      }  // container mpls-exp

      container mpls-exp-imp {
        when
          "../type = 'match-type-mpls-exp-imp'" {
          description
            "../type = 'MATCH_TYPE_MPLS_EXP_IMP'";
        }
        description
          "Match MPLS experimental imposition array";
        uses UINT8-ARRAY;
      }  // container mpls-exp-imp

      container mpls-disp-ipv4-acl {
        when
          "../type = 'match-type-mpls-disp-ipv4-acl'" {
          description
            "../type = 'MATCH_TYPE_MPLS_DISP_IPV4_ACL'";
        }
        description
          "MPLS Disposition IPv4 Access-list";
        uses STRING-ARRAY;
      }  // container mpls-disp-ipv4-acl

      container mpls-disp-ipv6-acl {
        when
          "../type = 'match-type-mpls-disp-ipv6-acl'" {
          description
            "../type = 'MATCH_TYPE_MPLS_DISP_IPV6_ACL'";
        }
        description
          "MPLS Disposition IPv6 Access-list";
        uses STRING-ARRAY;
      }  // container mpls-disp-ipv6-acl

      container mpls-disp-cl-map {
        when
          "../type = 'match-type-mpls-disp-cl-map'" {
          description
            "../type = 'MATCH_TYPE_MPLS_DISP_CMAP'";
        }
        description
          "MPLS Disposition Class Map";
        uses STRING-ARRAY;
      }  // container mpls-disp-cl-map

      container mpls-top-label {
        when
          "../type = 'match-type-mpls-topmost-label'" {
          description
            "../type = 'MATCH_TYPE_MPLS_TOPMOST_LABEL'";
        }
        description "MPLS Topmost LABEL";
        uses UINT32-RNG-ARRAY;
      }  // container mpls-top-label

      container cos {
        when "../type = 'match-type-cos'" {
          description
            "../type = 'MATCH_TYPE_COS'";
        }
        description "Match CoS array";
        uses UINT8-ARRAY;
      }  // container cos

      container cos-inr {
        when
          "../type = 'match-type-cos-inner'" {
          description
            "../type = 'MATCH_TYPE_COS_INNER'";
        }
        description "Match inner header CoS";
        uses UINT8-ARRAY;
      }  // container cos-inr

      container dei {
        when "../type = 'match-type-dei'" {
          description
            "../type = 'MATCH_TYPE_DEI'";
        }
        description "Match DEI Bit";
        uses DEI-BIT-ST;
      }  // container dei

      container dei-inr {
        when
          "../type = 'match-type-dei-inner'" {
          description
            "../type = 'MATCH_TYPE_DEI_INNER'";
        }
        description "Match inner DEI Bit";
        uses DEI-BIT-ST;
      }  // container dei-inr

      container vlan {
        when "../type = 'match-type-vlan'" {
          description
            "../type = 'MATCH_TYPE_VLAN'";
        }
        description "Match VLAN array";
        uses VLAN-ID-ARRAY;
      }  // container vlan

      container vlan-inr {
        when
          "../type = 'match-type-vlan-inner'" {
          description
            "../type = 'MATCH_TYPE_VLAN_INNER'";
        }
        description
          "Match inner header VLAN range array";
        uses UINT16-RNG-ARRAY;
      }  // container vlan-inr

      container fr-dlci {
        when
          "../type = 'match-type-fr-dlci'" {
          description
            "../type = 'MATCH_TYPE_FR_DLCI'";
        }
        description
          "Match FR DLCI range array";
        uses UINT16-RNG-ARRAY;
      }  // container fr-dlci

      container src-mac {
        when
          "../type = 'match-type-src-mac'" {
          description
            "../type = 'MATCH_TYPE_SRC_MAC'";
        }
        description
          "Match Source MAC address";
        uses MAC-ADDR-ST;
      }  // container src-mac

      container dst-mac {
        when
          "../type = 'match-type-dst-mac'" {
          description
            "../type = 'MATCH_TYPE_DST_MAC'";
        }
        description
          "Match Destination MAC address";
        uses MAC-ADDR-ST;
      }  // container dst-mac

      container atm-clp {
        when
          "../type = 'match-type-atm-clp'" {
          description
            "../type = 'MATCH_TYPE_ATM_CLP'";
        }
        description "Match ATM CLP level";
        uses UINT8-ARRAY;
      }  // container atm-clp

      container fr-de {
        when "../type = 'match-type-fr-de'" {
          description
            "../type = 'MATCH_TYPE_FR_DE'";
        }
        description "Match FR DE value";
        uses UINT8-ARRAY;
      }  // container fr-de

      container ipv4-acl {
        when
          "../type = 'match-type-ipv4-acl'" {
          description
            "../type = 'MATCH_TYPE_IPV4_ACL'";
        }
        description "IPv4 Access-list";
        uses STRING-ARRAY;
      }  // container ipv4-acl

      container ipv6-acl {
        when
          "../type = 'match-type-ipv6-acl'" {
          description
            "../type = 'MATCH_TYPE_IPV6_ACL'";
        }
        description "IPv6 Access-list";
        uses STRING-ARRAY;
      }  // container ipv6-acl

      container ether-service-acl {
        when
          "../type = 'match-type-ethernet-service-s-acl'" {
          description
            "../type = 'MATCH_TYPE_ETHERNET_SERVICES_ACL'";
        }
        description
          "Ethernet-Services Access-list";
        uses STRING-ARRAY;
      }  // container ether-service-acl

      container avail-id {
        when
          "../type = 'match-type-avail-id'" {
          description
            "../type = 'MATCH_TYPE_AVAIL_ID'";
        }
        description "Available Identifiers";
        uses UINT8-ARRAY;
      }  // container avail-id

      container media-type {
        when "../type = 'match-type-media'" {
          description
            "../type = 'MATCH_TYPE_MEDIA'";
        }
        description "Media Type";
        uses UINT8-ARRAY;
      }  // container media-type

      container subs-protocol {
        when
          "../type = 'match-type-subs-protocol'" {
          description
            "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
        }
        description "Protocol";
        uses UINT8-ARRAY;
      }  // container subs-protocol

      container dnis {
        when "../type = 'match-type-dnis'" {
          description
            "../type = 'MATCH_TYPE_DNIS'";
        }
        description "DNIS";
        uses STRING-ARRAY;
      }  // container dnis

      container dnis-regex {
        when
          "../type = 'match-type-dnis-regexp'" {
          description
            "../type = 'MATCH_TYPE_DNIS_REGEXP'";
        }
        description
          "DNIS Regular Expression";
        uses STRING-ARRAY;
      }  // container dnis-regex

      container domain {
        when "../type = 'match-type-domain'" {
          description
            "../type = 'MATCH_TYPE_DOMAIN'";
        }
        description "Domain Name";
        uses DOMAIN-ARRAY;
      }  // container domain

      container domain-regex {
        when
          "../type = 'match-type-domain-regexp'" {
          description
            "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
        }
        description
          "Domain Regular Expression";
        uses DOMAIN-ARRAY;
      }  // container domain-regex

      container nas-port {
        when
          "../type = 'match-type-nas-port'" {
          description
            "../type = 'MATCH_TYPE_NAS_PORT'";
        }
        description "NAS Port";
        uses NAS-PORT-ARRAY;
      }  // container nas-port

      container service-name {
        when
          "../type = 'match-type-service-name'" {
          description
            "../type = 'MATCH_TYPE_SERVICE_NAME'";
        }
        description "Service Name";
        uses STRING-ARRAY;
      }  // container service-name

      container service-name-regex {
        when
          "../type = 'match-type-service-name-regexp'" {
          description
            "../type = 'MATCH_TYPE_SERVICE_NAME_REGEXP'";
        }
        description
          "Service Name Regular Exp";
        uses STRING-ARRAY;
      }  // container service-name-regex

      container src-addr-ipv4 {
        when
          "../type = 'match-type-src-addr-ipv4'" {
          description
            "../type = 'MATCH_TYPE_SRC_ADDR_IPV4'";
        }
        description "Source Address IPV4";
        uses IPV4-ADDR-ARRAY;
      }  // container src-addr-ipv4

      container dst-addr-ipv4 {
        when
          "../type = 'match-type-dst-addr-ipv4'" {
          description
            "../type = 'MATCH_TYPE_DST_ADDR_IPV4'";
        }
        description
          "Destination Address IPV4";
        uses IPV4-ADDR-ARRAY;
      }  // container dst-addr-ipv4

      container src-addr-ipv6 {
        when
          "../type = 'match-type-src-addr-ipv6'" {
          description
            "../type = 'MATCH_TYPE_SRC_ADDR_IPV6'";
        }
        description "Source Address IPV6";
        uses IPV6-ADDR-ARRAY;
      }  // container src-addr-ipv6

      container dst-addr-ipv6 {
        when
          "../type = 'match-type-dst-addr-ipv6'" {
          description
            "../type = 'MATCH_TYPE_DST_ADDR_IPV6'";
        }
        description
          "Destination Address IPV6";
        uses IPV6-ADDR-ARRAY;
      }  // container dst-addr-ipv6

      container src-addr-mac {
        when
          "../type = 'match-type-src-addr-mac'" {
          description
            "../type = 'MATCH_TYPE_SRC_ADDR_MAC'";
        }
        description "Source Address MAC";
        uses MAC-ADDR-ARRAY;
      }  // container src-addr-mac

      container timer {
        when "../type = 'match-type-timer'" {
          description
            "../type = 'MATCH_TYPE_TIMER'";
        }
        description "Timer";
        uses STRING-ARRAY;
      }  // container timer

      container timer-regexp {
        when
          "../type = 'match-type-timer-regexp'" {
          description
            "../type = 'MATCH_TYPE_TIMER_REGEXP'";
        }
        description
          "Timer Regular Expression";
        uses STRING-ARRAY;
      }  // container timer-regexp

      container tunnel-name {
        when
          "../type = 'match-type-tunnel-name'" {
          description
            "../type = 'MATCH_TYPE_TUNNEL_NAME'";
        }
        description "Tunnel Name";
        uses STRING-ARRAY;
      }  // container tunnel-name

      container tunnel-name-regex {
        when
          "../type = 'match-type-tunnel-name-regexp'" {
          description
            "../type = 'MATCH_TYPE_TUNNEL_NAME_REGEXP'";
        }
        description
          "Tunnel Name Regular Expression";
        uses STRING-ARRAY;
      }  // container tunnel-name-regex

      container user-name {
        when
          "../type = 'match-type-user-name'" {
          description
            "../type = 'MATCH_TYPE_USERNAME'";
        }
        description "User Name";
        uses STRING-ARRAY;
      }  // container user-name

      container user-name-regex {
        when
          "../type = 'match-type-user-name-regexp'" {
          description
            "../type = 'MATCH_TYPE_USERNAME_REGEXP'";
        }
        description
          "User Name Regular Expression";
        uses STRING-ARRAY;
      }  // container user-name-regex

      container auth-username {
        when
          "../type = 'match-type-auth-user-name'" {
          description
            "../type = 'MATCH_TYPE_AUTH_USERNAME'";
        }
        description
          "Authenticated User Name";
        uses STRING-ARRAY;
      }  // container auth-username

      container auth-username-regex {
        when
          "../type = 'match-type-auth-user-name-regexp'" {
          description
            "../type = 'MATCH_TYPE_AUTH_USERNAME_REGEXP'";
        }
        description
          "Authenticated User Name RegEx";
        uses STRING-ARRAY;
      }  // container auth-username-regex

      container unauth-username {
        when
          "../type = 'match-type-unauth-user-name'" {
          description
            "../type = 'MATCH_TYPE_UNAUTH_USERNAME'";
        }
        description
          "Unauthenticated User Name";
        uses STRING-ARRAY;
      }  // container unauth-username

      container unauth-username-regex {
        when
          "../type = 'match-type-unauth-user-name-regexp'" {
          description
            "../type = 'MATCH_TYPE_UNAUTH_USERNAME_REGEXP'";
        }
        description
          "Unauthenticated User Name RegEx";
        uses STRING-ARRAY;
      }  // container unauth-username-regex

      container auth-domain {
        when
          "../type = 'match-type-auth-domain'" {
          description
            "../type = 'MATCH_TYPE_AUTH_DOMAIN'";
        }
        description
          "Authenticated domain name";
        uses STRING-ARRAY;
      }  // container auth-domain

      container auth-domain-regex {
        when
          "../type = 'match-type-auth-domain-regexp'" {
          description
            "../type = 'MATCH_TYPE_AUTH_DOMAIN_REGEXP'";
        }
        description
          "Authenticated Domain Name RegEx";
        uses STRING-ARRAY;
      }  // container auth-domain-regex

      container unauth-domain {
        when
          "../type = 'match-type-unauth-domain'" {
          description
            "../type = 'MATCH_TYPE_UNAUTH_DOMAIN'";
        }
        description
          "Unauthenticated Domain Name";
        uses STRING-ARRAY;
      }  // container unauth-domain

      container unauth-domain-regex {
        when
          "../type = 'match-type-unauth-domain-regexp'" {
          description
            "../type = 'MATCH_TYPE_UNAUTH_DOMAIN_REGEXP'";
        }
        description
          "Unauthenticated Domain Name RegEx";
        uses STRING-ARRAY;
      }  // container unauth-domain-regex

      container vendor-id {
        when
          "../type = 'match-type-vendor-id'" {
          description
            "../type = 'MATCH_TYPE_VENDOR_ID'";
        }
        description "Vendor ID";
        uses STRING-ARRAY;
      }  // container vendor-id

      container vendor-id-regex {
        when
          "../type = 'match-type-vendor-id-regexp'" {
          description
            "../type = 'MATCH_TYPE_VENDOR_ID_REGEXP'";
        }
        description "Vendor ID RegEx";
        uses STRING-ARRAY;
      }  // container vendor-id-regex

      container access-interface {
        when
          "../type = 'match-type-access-interface'" {
          description
            "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
        }
        description "Access interface";
        uses STRING-ARRAY;
      }  // container access-interface

      container input-interface {
        when
          "../type = 'match-type-input-interface'" {
          description
            "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
        }
        description "Input interface";
        uses STRING-ARRAY;
      }  // container input-interface

      container ethertype {
        when
          "../type = 'match-type-ether-type'" {
          description
            "../type = 'MATCH_TYPE_ETHERTYPE'";
        }
        description "Ethernet type";
        uses UINT16-RNG-ARRAY;
      }  // container ethertype

      container flow-key-data {
        when
          "../type = 'match-type-flow-key'" {
          description
            "../type = 'MATCH_TYPE_FLOW_KEY'";
        }
        description "Flow key structure";
        uses FLOW-KEY-ST;
      }  // container flow-key-data

      container dhcp-client-id {
        when
          "../type = 'match-type-dhcp-client-id'" {
          description
            "../type = 'MATCH_TYPE_DHCP_CLIENT_ID'";
        }
        description "Dhcp Client ID";
        uses STRING-ARRAY;
      }  // container dhcp-client-id

      container dhcp-client-id-regex {
        when
          "../type = 'match-type-dhcp-client-id-regexp'" {
          description
            "../type = 'MATCH_TYPE_DHCP_CLIENT_ID_REGEXP'";
        }
        description "Dhcp Client ID RegEx";
        uses STRING-ARRAY;
      }  // container dhcp-client-id-regex

      container circuit-id {
        when
          "../type = 'match-type-circuit-id'" {
          description
            "../type = 'MATCH_TYPE_CIRCUIT_ID'";
        }
        description "Circuit ID";
        uses STRING-ARRAY;
      }  // container circuit-id

      container circuit-id-regex {
        when
          "../type = 'match-type-circuit-id-regexp'" {
          description
            "../type = 'MATCH_TYPE_CIRCUIT_ID_REGEXP'";
        }
        description "Circuit ID RegEx";
        uses STRING-ARRAY;
      }  // container circuit-id-regex

      container remote-id {
        when
          "../type = 'match-type-remote-id'" {
          description
            "../type = 'MATCH_TYPE_REMOTE_ID'";
        }
        description "Remote ID";
        uses STRING-ARRAY;
      }  // container remote-id

      container remote-id-regex {
        when
          "../type = 'match-type-remote-id-regexp'" {
          description
            "../type = 'MATCH_TYPE_REMOTE_ID_REGEXP'";
        }
        description "Remote ID RegEx";
        uses STRING-ARRAY;
      }  // container remote-id-regex

      container src-port {
        when
          "../type = 'match-type-src-port'" {
          description
            "../type = 'MATCH_TYPE_SRC_PORT'";
        }
        description "Source port";
        uses UINT16-RNG-ARRAY;
      }  // container src-port

      container dst-port {
        when
          "../type = 'match-type-dst-port'" {
          description
            "../type = 'MATCH_TYPE_DST_PORT'";
        }
        description "Destination port";
        uses UINT16-RNG-ARRAY;
      }  // container dst-port

      leaf type {
        type Match-type-en;
        description "type";
      }

      leaf mpls-top-eos {
        when
          "../type = 'match-type-mpls-topmost-eos'" {
          description
            "../type = 'MATCH_TYPE_MPLS_TOPMOST_EOS'";
        }
        type uint8;
        description "MPLS Topmost EOS";
      }

      leaf fragment-type {
        when
          "../type = 'match-type-fragment-type'" {
          description
            "../type = 'MATCH_TYPE_FRAGMENT_TYPE'";
        }
        type uint8;
        description "Fragment type";
      }

      leaf authen-status {
        when
          "../type = 'match-type-authen-status'" {
          description
            "../type = 'MATCH_TYPE_AUTHEN_STATUS'";
        }
        type Match-authen-status-en;
        description "Authentication Status";
      }

      leaf mlp-negotiated {
        when
          "../type = 'match-type-mlp-negotiated'" {
          description
            "../type = 'MATCH_TYPE_MLP_NEGOTIATED'";
        }
        type Match-mlp-negotiated-en;
        description "MLP Negotiated";
      }
    }  // grouping CLASS-MATCH-DATA-UN

    grouping ACTION-OUTPUT-INTERFACE-INFO-P {
      description
        "ACTION OUTPUT INTERFACE INFO P";
      uses ACTION-OUTPUT-INTERFACE-INFO-ST;
    }  // grouping ACTION-OUTPUT-INTERFACE-INFO-P

    grouping UINT32-RNG-ARRAY {
      description "UINT32 RNG ARRAY";
      list uint32_rng_array {
        description "uint32 rng array";
        uses UINT32-RNG-ST;
      }  // list uint32_rng_array
    }  // grouping UINT32-RNG-ARRAY

    grouping TCP-FLAG-ST {
      description "TCP FLAG ST";
      leaf value {
        type uint16;
        description "Value of TCP flag";
      }

      leaf match-any {
        type boolean;
        description "Match any TCP flag bit";
      }
    }  // grouping TCP-FLAG-ST

    grouping ACTION-AUTHORIZE-ID-INFO-P {
      description
        "ACTION AUTHORIZE ID INFO P";
      uses ACTION-AUTHORIZE-ID-ST;
    }  // grouping ACTION-AUTHORIZE-ID-INFO-P

    grouping PLMGR-APPLIED-VARLIST-BG {
      description
        "Policy-map applied variable list";
      list var-list {
        description "var list";
        uses PLMGR-VAR-VAL-UN;
      }  // list var-list
    }  // grouping PLMGR-APPLIED-VARLIST-BG

    grouping ACTION-IPV6-NH-INFO-P {
      description "ACTION IPV6 NH INFO P";
      uses ACTION-IPV6-NH-INFO-ARRAY;
    }  // grouping ACTION-IPV6-NH-INFO-P

    grouping ACTION-PROXY-AAA-ST {
      description "ACTION PROXY AAA ST";
      leaf aaa-list-name {
        type string;
        description "aaa list name";
      }
    }  // grouping ACTION-PROXY-AAA-ST

    grouping ACTION-PROXY-AAA-INFO-P {
      description "ACTION PROXY AAA INFO P";
      uses ACTION-PROXY-AAA-ST;
    }  // grouping ACTION-PROXY-AAA-INFO-P

    grouping ACTION-SFRAG-INFO-ST {
      description "service fragment action";
      leaf name {
        type string;
        description "Service Fragment Name";
      }
    }  // grouping ACTION-SFRAG-INFO-ST

    grouping ACTION-MINBW-INFO-P {
      description "ACTION MINBW INFO P";
      uses ACTION-MINBW-INFO-ST;
    }  // grouping ACTION-MINBW-INFO-P

    grouping ACTION-PUNT-INFO-P {
      description "ACTION PUNT INFO P";
      uses ACTION-PUNT-INFO-ST;
    }  // grouping ACTION-PUNT-INFO-P

    grouping ACTION-COPY-INFO-P {
      description "ACTION COPY INFO P";
      uses ACTION-COPY-INFO-ST;
    }  // grouping ACTION-COPY-INFO-P

    grouping ACTION-DECODE-IDENTIFIER-INFO-P {
      description
        "ACTION DECODE IDENTIFIER INFO P";
      uses ACTION-DECODE-IDENTIFIER-ST;
    }  // grouping ACTION-DECODE-IDENTIFIER-INFO-P

    grouping ACTION-CAC-INFO-P {
      description "ACTION CAC INFO P";
      uses ACTION-CAC-INFO-ST;
    }  // grouping ACTION-CAC-INFO-P

    grouping PLMGR-OBJ-CMAP-DETAIL-BG {
      description "Object detail.";
      leaf total-reference-objects {
        type uint32;
        description
          "Total number of Policymaps referencing a
         Classmap";
      }

      list policy-map-reference {
        description
          "List of Policymaps referencing a Classmap";
        uses PLMGR-PMAP-LIST;
      }  // list policy-map-reference
    }  // grouping PLMGR-OBJ-CMAP-DETAIL-BG

    grouping ACTION-BWREM-INFO-ST {
      description "BW remaining action";
      container bwrem {
        description "bwrem";
        uses POLICY-PARAM-UINT32-ST;
      }  // container bwrem
    }  // grouping ACTION-BWREM-INFO-ST

    grouping PMAP-DATA-HD {
      description "PMAP DATA HD";
      uses POLICY-MAP-BG;
    }  // grouping PMAP-DATA-HD

    grouping ACTION-AFMON-REACT-INFO-P {
      description
        "ACTION AFMON REACT INFO P";
      uses ACTION-AFMON-REACT-INFO;
    }  // grouping ACTION-AFMON-REACT-INFO-P

    grouping POLICY-SUB-ACTIONS-T {
      description "";
      list sub-action-attribute {
        description "";
        uses POLICY-SUB-ACTION-ATTR-T;
      }  // list sub-action-attribute
    }  // grouping POLICY-SUB-ACTIONS-T

    grouping PLMGR-PIPELINE-CAP-BG {
      description
        " Pipeline capabilities details";
      list pipeline-capability {
        description "Pipelinecapability";
        uses PLMGR-APP-PLN-CAPS-T;
      }  // list pipeline-capability
    }  // grouping PLMGR-PIPELINE-CAP-BG

    grouping ACTION-MARK-INFO-ST {
      description "Mark action";
      leaf type {
        type Mark-type-en;
        description "type";
      }

      leaf mark-flags {
        type uint32;
        description "mark flags";
      }

      leaf value {
        type uint16;
        description "value";
      }
    }  // grouping ACTION-MARK-INFO-ST

    grouping ACTION-TIMEOUT-IDLE-ST {
      description "ACTION TIMEOUT IDLE ST";
      leaf secs {
        type uint32;
        description "secs";
      }
    }  // grouping ACTION-TIMEOUT-IDLE-ST

    grouping ACTION-AFMON-MDI-INFO-P {
      description "ACTION AFMON MDI INFO P";
      uses ACTION-AFMON-MDI-INFO-ST;
    }  // grouping ACTION-AFMON-MDI-INFO-P

    grouping ACTION-MINBW-INFO-ST {
      description "Min BW action";
      container bw {
        description "bw";
        uses POLICY-PARAM-UINT32-ST;
      }  // container bw
    }  // grouping ACTION-MINBW-INFO-ST

    grouping POLICY-MAP-NAME-TYPE {
      description
        "Policy-map name type info";
      list policy-map-name-type {
        description
          "policy map type and name";
        uses POLICY-MAP-TYPE-N-NAME-ST;
      }  // list policy-map-name-type
    }  // grouping POLICY-MAP-NAME-TYPE

    grouping POLICY-MAP-HD-ST {
      description "POLICY MAP HD ST";
      container data-hd {
        description "data hd";
        uses POLICY-MAP-NAME-TYPE;
      }  // container data-hd
    }  // grouping POLICY-MAP-HD-ST

    grouping MATCH-DOMAIN-ST {
      description "Domain Format";
      leaf domain-name {
        type string;
        description "domain name";
      }

      leaf format-name {
        type string;
        description "format name";
      }
    }  // grouping MATCH-DOMAIN-ST

    grouping STRING-ARRAY {
      description "STRING ARRAY";
      leaf-list string-array {
        type string;
        description "string array";
      }
    }  // grouping STRING-ARRAY

    grouping ACTION-ACCT-AAA-LIST-ST {
      description "ACTION ACCT AAA LIST ST";
      leaf aaa-list-name {
        type string;
        description "aaa list name";
      }

      leaf secs {
        type uint32;
        description "secs";
      }
    }  // grouping ACTION-ACCT-AAA-LIST-ST

    grouping PMAP-VAR-INFO-ST {
      description
        "contains the name of the
       variable argument and the value configured";
      container val {
        description "val";
        uses PLMGR-VAR-VAL-UN;
      }  // container val

      leaf name {
        type string {
          length "0..32";
        }
        description "name";
      }

      leaf id {
        type uint32;
        description "id";
      }
    }  // grouping PMAP-VAR-INFO-ST

    grouping PLMGR-PMAP-STR-TARGETS-BG {
      description
        "Policymap and target info returned to the show
       client";
      leaf-list targets {
        type string;
        description "targets";
      }

      leaf-list parent-targets {
        type string;
        description "parent targets";
      }
    }  // grouping PLMGR-PMAP-STR-TARGETS-BG

    grouping IPV6-ADDR-ARRAY {
      description "IPV6 ADDR ARRAY";
      list ipv6-addr-array {
        description "ipv6 addr array";
        uses MATCH-IPV6-ST;
      }  // list ipv6-addr-array
    }  // grouping IPV6-ADDR-ARRAY

    grouping PLMGR-APP-PLN-CAPS-T {
      description
        " Pipe line capabilty info";
      leaf pipeline-id {
        type uint32;
        description "Pipe line id";
      }

      leaf description {
        type string;
        description "Description";
      }

      leaf-list table-type {
        type Policy-map-table-type-e;
        description
          "List of table types in the pipeline  in the
         order";
      }
    }  // grouping PLMGR-APP-PLN-CAPS-T

    grouping PLMGR-APP-GL-STATUS-CAP-T {
      description
        "Status capabilty of a network element";
      leaf status-per-match {
        type boolean;
        description
          "Filter operation status capability";
      }

      leaf status-per-action {
        type boolean;
        description
          "Action operation status capability";
      }

      leaf status-per-inline-class {
        type boolean;
        description
          "Inline class operation status capability";
      }

      leaf status-per-class-map {
        type boolean;
        description
          "Class map operation status capability";
      }

      leaf status-per-policy-map {
        type boolean;
        description
          "Policy map operation status capability";
      }

      leaf status-per-bulk {
        type boolean;
        description
          "Bulk operation status capability";
      }
    }  // grouping PLMGR-APP-GL-STATUS-CAP-T

    grouping POLICY-SUB-ACTION-ATTR-T {
      description "";
      container action-attribute {
        description "";
        uses POLICY-ACTION-ATTR-T;
      }  // container action-attribute

      leaf sub-action {
        type uint32;
        description "";
      }
    }  // grouping POLICY-SUB-ACTION-ATTR-T

    grouping ACTION-AFMON-FMM-INFO-ST {
      description
        "AFMon flow monitor configuration";
      leaf fmm-name {
        type string {
          length "0..33";
        }
        description "flow monitor name";
      }
    }  // grouping ACTION-AFMON-FMM-INFO-ST

    grouping ACTION-WRED-INFO-ST {
      description
        "WRED parameters info structure";
      container match-ranges {
        description "match ranges";
        uses UINT8-RNG-ARRAY;
      }  // container match-ranges

      container min-threshold {
        description "min threshold";
        uses POLICY-PARAM-UINT32-ST;
      }  // container min-threshold

      container max-threshold {
        description "max threshold";
        uses POLICY-PARAM-UINT32-ST;
      }  // container max-threshold

      leaf type {
        type Wred-type-en;
        description
          "cos/prec/dscp/ based WRED";
      }

      leaf wred-flags {
        type uint32;
        description "wred flags";
      }

      leaf probability {
        type uint32;
        description "probability";
      }
    }  // grouping ACTION-WRED-INFO-ST

    grouping ACTION-AFMON-FLOW-PARM-INFO-P {
      description
        "ACTION AFMON FLOW PARM INFO P";
      uses ACTION-AFMON-FLOW-PARM-INFO-ST;
    }  // grouping ACTION-AFMON-FLOW-PARM-INFO-P

    grouping ACTION-MARK-INFO-P {
      description "ACTION MARK INFO P";
      uses ACTION-MARK-INFO;
    }  // grouping ACTION-MARK-INFO-P

    grouping ACTION-PUNT-INFO-ST {
      description "punt action";
      leaf sn-type {
        type Dpss-snid-type-en;
        description "service node ID type";
      }

      leaf sn-index {
        type uint32;
        description "service node index";
      }

      leaf sn-name {
        type string;
        description "service node name";
      }

      leaf app-id {
        type uint32;
        description "application ID";
      }

      leaf local-id {
        type uint32;
        description "local ID";
      }

      leaf vsnode-type {
        type Vsvc-service-type-t;
        description "vservice node type";
      }
    }  // grouping ACTION-PUNT-INFO-ST

    grouping PLMGR-VRF-STATS-ARR-BG {
      description "The array bag";
      leaf pmap-name {
        type string;
        description "pmap name";
      }

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

      leaf appln-type {
        type uint32;
        description "appln type";
      }

      leaf addr-family {
        type uint32;
        description "addr family";
      }

      leaf rc {
        type int32;
        description "rc";
      }

      list plmgr-vrf-stats {
        description "plmgr vrf stats";
        uses PLMGR-VRF-STATS-BG;
      }  // list plmgr-vrf-stats
    }  // grouping PLMGR-VRF-STATS-ARR-BG

    grouping UINT8-RNG-ARRAY {
      description "UINT8 RNG ARRAY";
      list uint8_rng_array {
        description "uint8 rng array";
        uses UINT8-RNG-ST;
      }  // list uint8_rng_array
    }  // grouping UINT8-RNG-ARRAY

    grouping POLICE-ACTION-ARRAY {
      description "POLICE ACTION ARRAY";
      list police-action-array {
        description "police action array";
        uses POLICE-ACTION-UN;
      }  // list police-action-array
    }  // grouping POLICE-ACTION-ARRAY

    grouping POLICY-MAP-TYPE-N-NAME-ST {
      description
        "POLICY MAP TYPE N NAME ST";
      leaf name {
        type Policy-map-name;
        description "name";
      }

      leaf type {
        type Policy-map-type-en;
        description "type";
      }
    }  // grouping POLICY-MAP-TYPE-N-NAME-ST

    grouping ACTION-PBF-INFO-P {
      description "ACTION PBF INFO P";
      uses ACTION-PBF-INFO-ARRAY;
    }  // grouping ACTION-PBF-INFO-P

    grouping ACTION-ACCT-EVENT-INFO-P {
      description "ACTION ACCT EVENT INFO P";
      uses ACTION-ACCOUNTING-EVENT-ST;
    }  // grouping ACTION-ACCT-EVENT-INFO-P

    grouping ACTION-SET-TIMER-ST {
      description "ACTION SET TIMER ST";
      leaf timer-name {
        type string;
        description "timer name";
      }

      leaf duration {
        type uint32;
        description "duration";
      }

      leaf absolute-time {
        type string;
        description "absolute time";
      }
    }  // grouping ACTION-SET-TIMER-ST

    grouping ACTION-AFMON-RTP-INFO-ST {
      description "AFMon RTP Configuration";
      leaf action-metric-type {
        type Policy-action-en;
        description "metric type";
      }

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

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

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

      leaf seq-ext-cop4 {
        type uint32;
        description
          "enable seq extension cop4";
      }

      list clock-rate {
        description "clock rate";
        uses AFMON-RTP-CLOCK-RATE-ST;
      }  // list clock-rate
    }  // grouping ACTION-AFMON-RTP-INFO-ST

    grouping PCLASS-MOD-DATA-HD {
      description "PCLASS MOD DATA HD";
      uses POLICY-CLASS-INFO-MOD-BG;
    }  // grouping PCLASS-MOD-DATA-HD

    grouping PLMGR-PCLASS-DIFF-BG {
      description "Policy-class diff Bag";
      container del {
        description "del";
        uses POLICY-CLASS-INFO-UN;
      }  // container del

      container mod {
        description "mod";
        uses POLICY-CLASS-INFO-UN;
      }  // container mod

      container add {
        description "add";
        uses POLICY-CLASS-INFO-UN;
      }  // container add
    }  // grouping PLMGR-PCLASS-DIFF-BG

    grouping ACTION-MARK2-INFO-P {
      description "ACTION MARK2 INFO P";
      uses ACTION-MARK2-INFO;
    }  // grouping ACTION-MARK2-INFO-P

    grouping ACTION-IPV6-NH-INFO-ST {
      description "ipv6 next hop action";
      leaf ipv6-nh-addr {
        type inet:ipv6-address;
        description "IPV6 Address";
      }

      leaf vrf-name {
        type string;
        description "Vrf name";
      }
    }  // grouping ACTION-IPV6-NH-INFO-ST

    grouping PLMGR-APP-GL-ATOMICITY-CAP-T {
      description
        " Atomicity capability of network element ";
      leaf atomicity-per-bulk {
        type boolean;
        description
          "Specifies policymgr bulk configuration atomicity
         supported or not";
      }

      leaf atomicity-per-inline-class {
        type boolean;
        description
          "Specifies policymgr inline class configuration
         atomicity supported or not";
      }

      leaf atomicity-per-policy-map {
        type boolean;
        description
          "Specifies policymgr policy-map configuration
         atomicity supported or not";
      }
    }  // grouping PLMGR-APP-GL-ATOMICITY-CAP-T

    grouping PLMGR-APP-TB-MATCH-CAP-T {
      description "Match capability";
      leaf match-capability-type {
        type Match-cap-e;
        description "Match type";
      }

      list match-attribute {
        description "Match attribute";
        uses PLMGR-MATCH-ATTR-UN;
      }  // list match-attribute
    }  // grouping PLMGR-APP-TB-MATCH-CAP-T

    grouping ACTION-STOP-TIMER-ST {
      description "ACTION STOP TIMER ST";
      leaf timer-name {
        type string;
        description "timer name";
      }
    }  // grouping ACTION-STOP-TIMER-ST

    grouping CHLD-POL-ENC-UNION {
      description
        "ACTION SERVICE POLICY INFO ARRAY";
      list action-policy-info-st {
        description "child policy info";
        uses CHLD-POL-ENC-UN;
      }  // list action-policy-info-st
    }  // grouping CHLD-POL-ENC-UNION

    grouping CHLD-POL-ENC-UN {
      description
        "Union of object name and app object ptr";
      container info {
        when
          "../enc = 'policy-obj-enc-name'" {
          description
            "../enc = 'POLICY_OBJ_ENC_NAME'";
        }
        description "info";
        uses POLICY-MAP-TYPE-N-NAME-ST;
      }  // container info

      container hd-info {
        when "../enc = 'policy-obj-enc-hdl'" {
          description
            "../enc = 'POLICY_OBJ_ENC_HDL'";
        }
        description "hd info";
        uses POLICY-MAP-HD-ST;
      }  // container hd-info

      leaf enc {
        type Policy-obj-enc-en;
        description "enc";
      }
    }  // grouping CHLD-POL-ENC-UN

    grouping POLICY-CLASS-INFO-BG {
      description "Class per policy info";
      list policy-class-info-bg {
        description "policy class info bg";
        container clmp-p {
          description "clmp p";
          uses CLASS-MAP-BG;
        }  // container clmp-p

        container act-infop {
          description "act infop";
          uses POLICY-ACTION-INFO-ST;
        }  // container act-infop

        container nlri-infop {
          description "nlri info pointer";
          uses PCLASS-NLRI-INFO-ST;
        }  // container nlri-infop

        leaf policy-class-hd {
          type uint32;
          description "policy class hd";
        }

        leaf seq {
          type uint32;
          description "seq";
        }

        leaf flags {
          type uint32;
          description "flags";
        }

        leaf ctype {
          type Class-map-type-en;
          description "ctype";
        }

        leaf num-actions {
          type uint16;
          description "num actions";
        }

        leaf version {
          type uint8;
          description "version";
        }

        leaf exe-strat {
          type Pclass-exec-strat-en;
          description "exe strat";
        }
      }  // list policy-class-info-bg
    }  // grouping POLICY-CLASS-INFO-BG

    grouping ACTION-TEMPLATE-ST {
      description "ACTION TEMPLATE ST";
      leaf template-name {
        type string;
        description "template name";
      }

      leaf aaa-list-name {
        type string;
        description "aaa list name";
      }

      leaf flags {
        type uint32;
        description "flags";
      }
    }  // grouping ACTION-TEMPLATE-ST

    grouping ACTION-QLIMIT-INFO-ARRAY {
      description "ACTION QLIMIT INFO ARRAY";
      list action-qlimit-info-array {
        description
          "action qlimit info array";
        uses ACTION-QLIMIT-INFO-ST;
      }  // list action-qlimit-info-array
    }  // grouping ACTION-QLIMIT-INFO-ARRAY

    grouping UINT16-ARRAY {
      description "UINT16 ARRAY";
      leaf-list uint16_array {
        type uint16;
        description "uint16 array";
      }
    }  // grouping UINT16-ARRAY

    grouping ACTION-MARK2-INFO-ST {
      description "Mark action";
      leaf value {
        type uint32;
        description "value";
      }

      leaf value-overflow {
        type uint16;
        description "value overflow";
      }

      leaf type {
        type Mark-type-e;
        description "type";
      }

      leaf mark-flags {
        type uint8;
        description "mark flags";
      }
    }  // grouping ACTION-MARK2-INFO-ST

    grouping ACTION-AFMON-REACT-INFO {
      description "ACTION AFMON REACT INFO";
      list action-afmon-react-info {
        description
          "action afmon react info";
        uses ACTION-AFMON-REACT-ST;
      }  // list action-afmon-react-info
    }  // grouping ACTION-AFMON-REACT-INFO

    grouping PLMGR-APP-TB-STATS-CAP-T {
      description " Table stats capability";
      leaf class-aggregate-targetaggregate-stats {
        type boolean;
        description
          "Specifies if complete table stats is  supported
         or not";
      }

      leaf class-target-aggregate {
        type boolean;
        description
          "Specifies if  class statistics  aggregated for
         all targets is  supporte dor not";
      }

      leaf class-target-stats {
        type boolean;
        description
          "Specifies if class statistics for each target
         supported or not";
      }

      leaf table-target-stats {
        type boolean;
        description
          "Specifies if per targets statistics retrieval is
         supporte dor not";
      }

      leaf action-taget-stats {
        type boolean;
        description
          "Specifies per action per target statistics
         supoorted or not";
      }
    }  // grouping PLMGR-APP-TB-STATS-CAP-T

    grouping PROTO-ICMP-ST {
      description "PROTO ICMP ST";
      leaf type {
        type uint8;
        description "Protocol type";
      }

      leaf code {
        type uint8;
        description "Protocol code";
      }
    }  // grouping PROTO-ICMP-ST

    grouping ACTION-OUTPUT-INTERFACE-INFO-ST {
      description "output_interface action";
      leaf out-ifname {
        type string;
        description "output interface name";
      }
    }  // grouping ACTION-OUTPUT-INTERFACE-INFO-ST

    grouping VLAN-ID-ARRAY {
      description "VLAN ID ARRAY";
      list vlan-id-array {
        description "vlan id array";
        uses VLAN-ID-ST;
      }  // list vlan-id-array
    }  // grouping VLAN-ID-ARRAY

    grouping PLMGR-PMAP-TARGETS-BG {
      description
        "Policymap and targets info. returned to Policymgr
       (from policy client)";
      leaf policy-map-name {
        type string {
          length "0..64";
        }
        description "PolicyMapName";
      }

      leaf num-targets {
        type uint32;
        description "NumTargets";
      }

      leaf num-parent-targets {
        type uint32;
        description "NumParentTargets";
      }

      leaf-list pmap-targets {
        type uint8;
        description "pmap targets";
      }

      leaf-list pmap-parent-targets {
        type uint8;
        description "pmap parent targets";
      }
    }  // grouping PLMGR-PMAP-TARGETS-BG

    grouping PLMGR-PMAP-LIST {
      description "policy-map list";
      leaf object-type {
        type Plmgr-appln-type-en;
        description
          "Application type configured";
      }

      leaf policy-map-name {
        type string {
          length "0..64";
        }
        description
          "Name of Policymap referencing a Classmap";
      }
    }  // grouping PLMGR-PMAP-LIST

    grouping ACTION-REDIRECT-INFO-P {
      description "ACTION REDIRECT INFO P";
      uses ACTION-REDIRECT-INFO-ST;
    }  // grouping ACTION-REDIRECT-INFO-P

    grouping POLICY-EVENT-INFO-BG {
      description "Event info bag";
      list policy-event-info-bg {
        description "policy event info bg";
        container class-infop {
          description "class infop";
          uses POLICY-CLASS-INFO-BG;
        }  // container class-infop

        leaf event-type {
          type Pevent-type-en;
          description "event type";
        }

        leaf cond-eval {
          type Pevent-cond-eval-en;
          description "cond eval";
        }
      }  // list policy-event-info-bg
    }  // grouping POLICY-EVENT-INFO-BG

    grouping INLINE-CMAP-DATA-HD {
      description "INLINE CMAP DATA HD";
      uses INLINE-CLASS-MAP-BG;
    }  // grouping INLINE-CMAP-DATA-HD

    grouping UINT8-RNG-ST {
      description "UINT8 RNG ST";
      leaf min {
        type uint8;
        description
          "Lower limit of the range";
      }

      leaf max {
        type uint8;
        description
          "Upper limit of the range";
      }
    }  // grouping UINT8-RNG-ST

    grouping PLMGR-APP-TB-CAPS-T {
      description
        "Policymgr application table capabilty info";
      container stats-capabilty {
        description "Stats capabaility";
        uses PLMGR-APP-TB-STATS-CAP-T;
      }  // container stats-capabilty

      container transient-capability {
        description "Transient capability";
        uses PLMGR-APP-TB-TRANSIENT-CAP-T;
      }  // container transient-capability

      container persistent-capability {
        description "Persistent capability";
        uses PLMGR-APP-TB-PERSISTENT-CAP-T;
      }  // container persistent-capability

      container class-capability {
        description "Class capabaility";
        uses PLMGR-APP-TB-CLASS-CAP-T;
      }  // container class-capability

      leaf table-type {
        type Policy-map-table-type-e;
        description " Table type";
      }

      leaf-list forwarding-type {
        type Plmgr-app-fwding-type-e;
        description
          "Forwarding type supported ";
      }

      list match-capability {
        description "Match capability ";
        uses PLMGR-APP-TB-MATCH-CAP-T;
      }  // list match-capability

      list action-capability {
        description "Action capability";
        uses PLMGR-APP-TB-ACTION-CAP-T;
      }  // list action-capability
    }  // grouping PLMGR-APP-TB-CAPS-T

    grouping DOMAIN-ARRAY {
      description "DOMAIN ARRAY";
      list domain-array {
        description "domain array";
        uses MATCH-DOMAIN-ST;
      }  // list domain-array
    }  // grouping DOMAIN-ARRAY

    grouping FLOW-KEY-ST {
      description "FLOW KEY ST";
      container flow-keys {
        description "flow keys";
        uses FLOW-KEY-ARRAY;
      }  // container flow-keys

      leaf max-count {
        type uint16;
        description "Maximum count of flows";
      }

      leaf idle-timeout {
        type uint16;
        units "second";
        description
          "Idle timeout of flows (in seconds)";
      }
    }  // grouping FLOW-KEY-ST

    grouping POLICY-MAP-HDR-BG {
      description "Policy-map Header Bag";
      leaf name {
        type Policy-map-name;
        description "name";
      }

      leaf type {
        type Policy-map-type-en;
        description "type";
      }

      leaf table-id {
        type uint32;
        description "table id";
      }

      leaf flags {
        type uint32;
        description "flags";
      }
    }  // grouping POLICY-MAP-HDR-BG

    grouping ACTION-TEMPLATE-INFO-P {
      description "ACTION TEMPLATE INFO P";
      uses ACTION-TEMPLATE-ST;
    }  // grouping ACTION-TEMPLATE-INFO-P

    grouping ACTION-HTTPR-INFO-P {
      description "ACTION HTTPR INFO P";
      uses ACTION-HTTPR-INFO-ST;
    }  // grouping ACTION-HTTPR-INFO-P

    grouping ACTION-POLICE-INFO-P {
      description "ACTION POLICE INFO P";
      uses ACTION-POLICE-INFO-ST;
    }  // grouping ACTION-POLICE-INFO-P

    grouping VLAN-ID-ST {
      description "VLAN ID ST";
      leaf min {
        type uint16;
        description
          "Lower limit of the range";
      }

      leaf max {
        type uint16;
        description
          "Upper limit of the range";
      }

      leaf mask {
        type uint16;
        description "VLAN mask";
      }
    }  // grouping VLAN-ID-ST

    grouping PLMGR-APP-GL-CAP-T {
      description
        "Global capability of network element";
      container system-capability {
        description "system capability";
        uses PLMGR-APP-GL-SYSTEM-CAP-T;
      }  // container system-capability

      container atomicity-capability {
        description "atomicity capability";
        uses PLMGR-APP-GL-ATOMICITY-CAP-T;
      }  // container atomicity-capability

      container stats-capability {
        description "stats capability";
        uses PLMGR-APP-GL-STATS-CAP-T;
      }  // container stats-capability

      container cookie-capability {
        description "cookie capability";
        uses PLMGR-APP-GL-COOKIE-CAP-T;
      }  // container cookie-capability

      container status-capability {
        description "status capability";
        uses PLMGR-APP-GL-STATUS-CAP-T;
      }  // container status-capability

      container bulk-best-effort-capability {
        description
          "bulk best effort capability";
        uses PLMGR-APP-GL-BULK-BEST-EFFORT-CAP-T;
      }  // container bulk-best-effort-capability
    }  // grouping PLMGR-APP-GL-CAP-T

    grouping ACTION-WRED-INFO {
      description "ACTION WRED INFO";
      list action-wred-info {
        description "action wred info";
        uses ACTION-WRED-INFO-ST;
      }  // list action-wred-info
    }  // grouping ACTION-WRED-INFO

    grouping FLOW-KEY-ARRAY {
      description "FLOW KEY ARRAY";
      leaf keys {
        type yang:hex-string;
        description "keys";
      }

      leaf num {
        type uint8;
        description "num";
      }
    }  // grouping FLOW-KEY-ARRAY

    grouping UINT8-ARRAY {
      description "UINT8 ARRAY";
      leaf-list uint8_array {
        type uint8;
        description "uint8 array";
      }
    }  // grouping UINT8-ARRAY

    grouping PCLASS-NLRI-INFO-ST {
      description "nlri info structure";
      container nlri {
        description "nlri value";
        uses UINT8-ARRAY;
      }  // container nlri
    }  // grouping PCLASS-NLRI-INFO-ST

    grouping POLICY-ACTION-ATTR-T {
      description " Policy action attribute";
      leaf policy-action-exec-type {
        type Policy-action-exec-type-e;
        description
          "policy action exec type";
      }

      leaf num-instances {
        type uint32;
        description "num instances";
      }
    }  // grouping POLICY-ACTION-ATTR-T

    grouping ACTION-QUERY-ANCP-SESSION-ST {
      description
        "ACTION QUERY ANCP SESSION ST";
      leaf enable {
        type boolean;
        description "enable";
      }
    }  // grouping ACTION-QUERY-ANCP-SESSION-ST

    grouping MASK-ATTR-T {
      description
        "Mask attributes for a match type";
      leaf subnet {
        type boolean;
        description
          "Subnet mask support for a match type";
      }

      leaf arbitrary {
        type boolean;
        description
          "Arbitrary mask support for a match type";
      }

      leaf wild-card {
        type boolean;
        description
          "Wild card mask support for a match type";
      }
    }  // grouping MASK-ATTR-T

    grouping PLMGR-GLOBAL-CAP-BG {
      description
        "Global Capabaility details ";
      list global-capability {
        description "Global capability";
        uses PLMGR-APP-GL-CAP-T;
      }  // list global-capability
    }  // grouping PLMGR-GLOBAL-CAP-BG

    grouping UINT16-RNG-ST {
      description "UINT16 RNG ST";
      leaf min {
        type uint16;
        description
          "Lower limit of the range";
      }

      leaf max {
        type uint16;
        description
          "Upper limit of the range";
      }
    }  // grouping UINT16-RNG-ST

    grouping ACTION-PREPAID-CFG-ST {
      description "ACTION PREPAID CFG ST";
      leaf prepaid-config-profile-name {
        type string;
        description
          "prepaid config profile name";
      }
    }  // grouping ACTION-PREPAID-CFG-ST

    grouping PLMGR-APP-DB-BG {
      description
        "Per application Classmap/Policymap database";
      leaf object-type {
        type Plmgr-appln-type-en;
        description
          "Application type configured";
      }

      leaf total-objects {
        type uint32;
        description
          "Total number of objects configured for a
         specific object type";
      }

      leaf transient {
        type boolean;
        description "Transient object";
      }

      list reference {
        description "Each Policymap details";
        uses PLMGR-OBJ-REF-PMAP-BG;
      }  // list reference

      list objects {
        description "Each object details";
        uses PLMGR-OBJ-REF-SUMMARY-BG;
      }  // list objects

      list class-map-reference {
        description "Each Classmapdetails";
        uses PLMGR-OBJ-CMAP-DETAIL-BG;
      }  // list class-map-reference
    }  // grouping PLMGR-APP-DB-BG

    grouping TARGETS {
      description
        "Common node of node, global";
      container target-policy-map-types {
        description "Targets of a policymap";
        list target-policy-map-type {
          key "type";
          description
            "Policymgr application type";
          container policy-map-targets {
            description "Policy-map table";
            list policy-map-target {
              key "policy-map-name";
              description
                "Policy-map targets";
              leaf policy-map-name {
                type string {
                  length "1..63";
                }
                description
                  "Name of policy-map";
              }

              uses PLMGR-PMAP-STR-TARGETS-BG;
            }  // list policy-map-target
          }  // container policy-map-targets

          container policy-map-target-summary {
            description "Policy-map table";
            uses PLMGR-PMAP-TARGETS-SUMMARY-BG;
          }  // container policy-map-target-summary

          container target-summary-per-policy-maps {
            description
              "Policy-map table per Policy-map";
            list target-summary-per-policy-map {
              key "policy-map-name";
              description
                "Policy-map targets summary";
              leaf policy-map-name {
                type string {
                  length "1..63";
                }
                description
                  "Name of policy-map";
              }

              uses PLMGR-PMAP-TARGETS-SUMMARY-BG;
            }  // list target-summary-per-policy-map
          }  // container target-summary-per-policy-maps

          leaf type {
            type Policymgr-policy-map;
            description
              "The application type";
          }
        }  // list target-policy-map-type
      }  // container target-policy-map-types
    }  // grouping TARGETS

    grouping CLASS-MAP {
      description
        "Common node of node, global";
      container class-map {
        description
          "List of classmap details";
        container class-map-types {
          description
            "Application type of a classmap";
          list class-map-type {
            key "type";
            description
              "Policymgr application type";
            container class-map-details {
              description
                "Class-map detail table";
              list class-map-detail {
                key "class-map-name";
                description
                  "Class-map detail information";
                leaf class-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of class-map";
                }

                uses PLMGR-APP-DB-BG;
              }  // list class-map-detail
            }  // container class-map-details

            container class-maps {
              description
                "Class-map definition table";
              list class-map {
                key "class-map-name";
                description
                  "Class-map configuration";
                leaf class-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of class-map";
                }

                uses CLASS-MAP-BG;
              }  // list class-map
            }  // container class-maps

            container class-map-briefs {
              description
                "Class-map brief table";
              list class-map-brief {
                key "class-map-name";
                description
                  "Class-map brief information";
                leaf class-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of class-map";
                }

                uses PLMGR-APP-DB-BG;
              }  // list class-map-brief
            }  // container class-map-briefs

            leaf type {
              type Policymgr-class-map;
              description
                "The application type";
            }
          }  // list class-map-type
        }  // container class-map-types
      }  // container class-map
    }  // grouping CLASS-MAP

    grouping SUMMARY {
      description
        "Common node of node, global";
      container summary {
        description
          "Summary of policy-maps and class-maps configured";
        uses PLMGR-SUMMARY-BG;
      }  // container summary
    }  // grouping SUMMARY

    grouping POLICY-MAP {
      description
        "Common node of node, global";
      container policy-map {
        description
          "List of policymap details";
        container transient-policy-map-type-xr {
          description
            "Application type of transient policy-map";
          list transient-policy-map-type {
            key "type";
            description
              "Transient policy-map type";
            container transient-policy-map-names {
              description
                "Transient policy-map definition table";
              list transient-policy-map-name {
                key "policy-map-name";
                description
                  "Transient policy-map definition table";
                container class-handles {
                  description
                    "Transient policy-map class handle table";
                  list class-handle {
                    key "inline-classhandle";
                    description
                      "Transient policy-map class handle";
                    leaf inline-classhandle {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "inline class handle";
                    }

                    uses POLICY-MAP-BG;
                  }  // list class-handle
                }  // container class-handles

                container class-seq-nums {
                  description
                    "Transient policy-map sequence number table";
                  list class-seq-num {
                    key "sequence-num";
                    description
                      "Transient policy-map sequence number";
                    leaf sequence-num {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "sequence number";
                    }

                    uses POLICY-MAP-BG;
                  }  // list class-seq-num
                }  // container class-seq-nums

                container definition {
                  description
                    "Transient Policy-map type name";
                  uses POLICY-MAP-BG;
                }  // container definition

                leaf policy-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of policy-map";
                }
              }  // list transient-policy-map-name
            }  // container transient-policy-map-names

            leaf type {
              type Policymgr-policy-map;
              description
                "The application type";
            }
          }  // list transient-policy-map-type
        }  // container transient-policy-map-type-xr

        container policy-map-unused-types {
          description
            "Policy-map unused table";
          list policy-map-unused-type {
            key "type";
            description "Policy-map unused";
            container unuseds {
              description
                "Policy-map unused";
              list unused {
                key "policy-map-name";
                description
                  "Policy-map unused information";
                leaf policy-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of policy-map";
                }

                uses PLMGR-APP-DB-BG;
              }  // list unused
            }  // container unuseds

            leaf type {
              type Policymgr-policy-map;
              description
                "The application type";
            }
          }  // list policy-map-unused-type
        }  // container policy-map-unused-types

        container policy-map-types {
          description
            "Application type of a policymap";
          list policy-map-type {
            key "type";
            description
              "Policymgr application type";
            container policy-maps {
              description
                "Policy-map definition table";
              list policy-map {
                key "policy-map-name";
                description
                  "Policy-map configuration";
                leaf policy-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of policy-map";
                }

                uses POLICY-MAP-BG;
              }  // list policy-map
            }  // container policy-maps

            container policy-map-details {
              description "Policy-map table";
              list policy-map-detail {
                key "policy-map-name";
                description
                  "Policy-map detail information";
                leaf policy-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of policy-map";
                }

                uses PLMGR-APP-DB-BG;
              }  // list policy-map-detail
            }  // container policy-map-details

            container vrf-table {
              xr:xr-xml-map "policymgr_oper:VRFTable";
              description "VRF table";
              list vrf {
                xr:xr-xml-map "policymgr_oper:VRF";
                key "vrf-name";
                description
                  "VRF configuration";
                leaf vrf-name {
                  xr:xr-xml-map "policymgr_oper:VRFName";
                  type string {
                    length "1..63";
                  }
                  description "Name of Vrf";
                }

                container afi-table {
                  xr:xr-xml-map "policymgr_oper:AfITable";
                  description "AFI table";
                  list afi {
                    xr:xr-xml-map "policymgr_oper:AfI";
                    key "afi-type";
                    description
                      "Address family config";
                    leaf afi-type {
                      xr:xr-xml-map "policymgr_oper:Type";
                      type afi-enum;
                      description
                        "Name of AFI";
                    }

                    container stats {
                      xr:xr-xml-map "policymgr_oper:VrfStats";
                      uses PLMGR-VRF-STATS-ARR-BG;
                    }  // container stats
                  }  // list afi
                }  // container afi-table
              }  // list vrf
            }  // container vrf-table

            leaf type {
              type Policymgr-policy-map;
              description
                "The application type";
            }
          }  // list policy-map-type
        }  // container policy-map-types

        container transient-policy-map-types {
          description
            "Application type of transient policy-map list";
          list transient-policy-map-type {
            key "type";
            description
              "Transient policy-map type";
            container transient-list-unuseds {
              description
                "Transient policy-map list unused table";
              list transient-list-unused {
                key "policy-map-name";
                description
                  "Policy-map list unused";
                leaf policy-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of policy-map";
                }

                uses PLMGR-APP-DB-BG;
              }  // list transient-list-unused
            }  // container transient-list-unuseds

            leaf type {
              type Policymgr-policy-map;
              description
                "The application type";
            }
          }  // list transient-policy-map-type
        }  // container transient-policy-map-types
      }  // container policy-map
    }  // grouping POLICY-MAP

    grouping DETAIL {
      description
        "Common node of transient-input, transient-output";
      container detail {
        description "Policy map";
        uses POLICY-MAP-APPLIED-SHOW-BG;
      }  // container detail
    }  // grouping DETAIL

    grouping POLICYMGR-OPER-DETAIL {
      description
        "Common node of transient-input,
       transient-outputCommon node of output, input";
      container detail {
        description "WORD interface name";
        uses POLICY-MAP-APPLIED-SHOW-BG;
      }  // container detail
    }  // grouping POLICYMGR-OPER-DETAIL

    container policy-manager {
      config false;
      description
        "Policy-map operational data";
      container global {
        description
          "Global QOS operational data";
        container policy-map-global-cap {
          description
            "Policy Global Capability";
          uses PLMGR-GLOBAL-CAP-BG;
        }  // container policy-map-global-cap

        container policy-map-table-cap {
          xr:xr-xml-map "policymgr_oper:TableCapabilty";
          description
            "Policy Table Capability";
          container policy-table-cap-types {
            xr:xr-xml-map "policymgr_oper:TableType";
            description
              "Table Capability Types";
            container l2any {
              description
                "Tablecap for l2any";
              uses PLMGR-TABLE-CAP-BG;
            }  // container l2any

            container l2l3 {
              description
                "Tablecap for l2l3";
              uses PLMGR-TABLE-CAP-BG;
            }  // container l2l3

            container l3ds {
              description
                "Tablecap for l3ds";
              uses PLMGR-TABLE-CAP-BG;
            }  // container l3ds

            container l3ipv4 {
              description
                "Tablecap for l3ipv4";
              uses PLMGR-TABLE-CAP-BG;
            }  // container l3ipv4

            container qos-in {
              description
                "Tablecap for qos-in";
              uses PLMGR-TABLE-CAP-BG;
            }  // container qos-in

            container qos-out {
              description
                "Tablecap for qos-out";
              uses PLMGR-TABLE-CAP-BG;
            }  // container qos-out

            container traffic-in {
              description
                "Tablecap for traffic-in";
              uses PLMGR-TABLE-CAP-BG;
            }  // container traffic-in
          }  // container policy-table-cap-types
        }  // container policy-map-table-cap

        container policy-map-applied-types {
          description
            "List of Applied policymap details";
          list policy-map-applied-type {
            key "type";
            description
              "Policymgr application type";
            container if-names {
              description "Interface table";
              list if-name {
                key "interface-name";
                description
                  "WORD interface name";
                container input {
                  description
                    "Input direction table";
                  uses POLICYMGR-OPER-DETAIL;
                }  // container input

                container output {
                  description
                    "Output direction table";
                  uses POLICYMGR-OPER-DETAIL;
                }  // container output

                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Name of the interface";
                }
              }  // list if-name
            }  // container if-names

            leaf type {
              type Policymgr-policy-map;
              description
                "The application type";
            }
          }  // list policy-map-applied-type
        }  // container policy-map-applied-types

        container transient-policy-map-targets-types {
          description
            "Transient policy-map target table";
          list transient-policy-map-targets-type {
            key "type";
            description
              "Transient Policymgr application type";
            container transient-target-summary-per-policy-maps {
              description
                "Transient Policy-map table per Policy-map";
              list transient-target-summary-per-policy-map {
                key "policy-map-name";
                description
                  "Policy-map targets summary";
                leaf policy-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of policy-map";
                }

                uses PLMGR-PMAP-TARGETS-SUMMARY-BG;
              }  // list transient-target-summary-per-policy-map
            }  // container transient-target-summary-per-policy-maps

            container transient-policy-map-target-summary {
              description
                "Transient Policy-map table";
              uses PLMGR-PMAP-TARGETS-SUMMARY-BG;
            }  // container transient-policy-map-target-summary

            container transient-policy-map-targets {
              description
                "Transient Policy-map table";
              list transient-policy-map-target {
                key "policy-map-name";
                description
                  "Transient Policy-map targets";
                leaf policy-map-name {
                  type string {
                    length "1..63";
                  }
                  description
                    "Name of policy-map";
                }

                uses PLMGR-PMAP-STR-TARGETS-BG;
              }  // list transient-policy-map-target
            }  // container transient-policy-map-targets

            leaf type {
              type Policymgr-policy-map;
              description
                "The application type";
            }
          }  // list transient-policy-map-targets-type
        }  // container transient-policy-map-targets-types

        container transient-policy-map-applied-types {
          description
            "Transient policy-map applied type";
          list transient-policy-map-applied-type {
            key "type";
            description
              "Transient policy-map applied type";
            container transient-interface-names {
              description "Interface table";
              list transient-interface-name {
                key "interface-name";
                description
                  "WORD interface name";
                container transient-output {
                  description
                    "Output direction table";
                  uses DETAIL;
                }  // container transient-output

                container transient-input {
                  description
                    "Input direction table";
                  uses DETAIL;
                }  // container transient-input

                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Name of the interface";
                }
              }  // list transient-interface-name
            }  // container transient-interface-names

            leaf type {
              type Policymgr-policy-map;
              description
                "The application type";
            }
          }  // list transient-policy-map-applied-type
        }  // container transient-policy-map-applied-types

        uses TARGETS;

        uses CLASS-MAP;

        uses POLICY-MAP;

        uses SUMMARY;
      }  // container global
    }  // container policy-manager
  }  // module Cisco-IOS-XR-infra-policymgr-oper