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";
    }

    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";
          list global-capability {
            description "Global capability";
            container system-capability {
              description
                "system capability";
              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";
              }
            }  // container system-capability

            container atomicity-capability {
              description
                "atomicity capability";
              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";
              }
            }  // container atomicity-capability

            container stats-capability {
              description "stats capability";
              leaf maximum-class-stats-polling-rate {
                type uint32;
                description
                  "Maximum statistics polling rate supported by a
network in terms of class stats per sec";
              }
            }  // container stats-capability

            container cookie-capability {
              description
                "cookie capability";
              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";
              }
            }  // container cookie-capability

            container status-capability {
              description
                "status capability";
              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";
              }
            }  // container status-capability

            container bulk-best-effort-capability {
              description
                "bulk best effort capability";
              leaf best-effort-per-bulk-instance {
                type boolean;
                description
                  "Specifies policymgr supports bulk configuration
best effort behavior or not";
              }
            }  // container bulk-best-effort-capability
          }  // list global-capability
        }  // 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";
              list table-capabilty {
                description
                  "Table capability";
                container stats-capabilty {
                  description
                    "Stats capabaility";
                  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";
                  }
                }  // container stats-capabilty

                container transient-capability {
                  description
                    "Transient capability";
                  leaf transient {
                    type boolean;
                    description
                      "Table transient support";
                  }
                }  // container transient-capability

                container persistent-capability {
                  description
                    "Persistent capability";
                  leaf persistent {
                    type boolean;
                    description
                      "Table persistent support";
                  }
                }  // container persistent-capability

                container class-capability {
                  description
                    "Class capabaility";
                  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";
                  }
                }  // 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 ";
                  leaf match-capability-type {
                    type Match-cap-e;
                    description "Match type";
                  }

                  list match-attribute {
                    description
                      "Match attribute";
                    container val-attr {
                      when
                        "../match-attr-type = 'value'" {
                        description
                          "../match_attr_type = 'Value'";
                      }
                      description "val attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container val-attr

                    container rng-attr {
                      when
                        "../match-attr-type = 'range'" {
                        description
                          "../match_attr_type = 'Range'";
                      }
                      description "rng attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container rng-attr

                    container mask-attr {
                      when
                        "../match-attr-type = 'mask'" {
                        description
                          "../match_attr_type = 'Mask'";
                      }
                      description
                        "mask attr";
                      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";
                      }
                    }  // container mask-attr

                    leaf match-attr-type {
                      type Match-attr-e;
                      description
                        "match attr type";
                    }
                  }  // list match-attribute
                }  // list match-capability

                list action-capability {
                  description
                    "Action capability";
                  container policy-action-attribute {
                    description
                      "Policy Action attribute  info";
                    container sub-action {
                      when
                        "../action-type = 'sub-action-attribute'" {
                        description
                          "../action_type = 'SubActionAttribute'";
                      }
                      description
                        "sub action";
                      list sub-action-attribute {
                        description "";
                        container action-attribute {
                          description "";
                          leaf policy-action-exec-type {
                            type Policy-action-exec-type-e;
                            description
                              "policy action exec type";
                          }

                          leaf num-instances {
                            type uint32;
                            description
                              "num instances";
                          }
                        }  // container action-attribute

                        leaf sub-action {
                          type uint32;
                          description "";
                        }
                      }  // list sub-action-attribute
                    }  // container sub-action

                    container action-attr {
                      when
                        "../action-type = 'action-attribute'" {
                        description
                          "../action_type = 'ActionAttribute'";
                      }
                      description
                        "action attr";
                      leaf policy-action-exec-type {
                        type Policy-action-exec-type-e;
                        description
                          "policy action exec type";
                      }

                      leaf num-instances {
                        type uint32;
                        description
                          "num instances";
                      }
                    }  // container action-attr

                    leaf action-type {
                      type Policy-action-attr-en;
                      description
                        "action type";
                    }
                  }  // container policy-action-attribute

                  leaf policy-action {
                    type Policy-action-e;
                    description
                      "Policy action ";
                  }
                }  // list action-capability
              }  // list table-capabilty
            }  // container l2any

            container l2l3 {
              description
                "Tablecap for l2l3";
              list table-capabilty {
                description
                  "Table capability";
                container stats-capabilty {
                  description
                    "Stats capabaility";
                  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";
                  }
                }  // container stats-capabilty

                container transient-capability {
                  description
                    "Transient capability";
                  leaf transient {
                    type boolean;
                    description
                      "Table transient support";
                  }
                }  // container transient-capability

                container persistent-capability {
                  description
                    "Persistent capability";
                  leaf persistent {
                    type boolean;
                    description
                      "Table persistent support";
                  }
                }  // container persistent-capability

                container class-capability {
                  description
                    "Class capabaility";
                  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";
                  }
                }  // 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 ";
                  leaf match-capability-type {
                    type Match-cap-e;
                    description "Match type";
                  }

                  list match-attribute {
                    description
                      "Match attribute";
                    container val-attr {
                      when
                        "../match-attr-type = 'value'" {
                        description
                          "../match_attr_type = 'Value'";
                      }
                      description "val attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container val-attr

                    container rng-attr {
                      when
                        "../match-attr-type = 'range'" {
                        description
                          "../match_attr_type = 'Range'";
                      }
                      description "rng attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container rng-attr

                    container mask-attr {
                      when
                        "../match-attr-type = 'mask'" {
                        description
                          "../match_attr_type = 'Mask'";
                      }
                      description
                        "mask attr";
                      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";
                      }
                    }  // container mask-attr

                    leaf match-attr-type {
                      type Match-attr-e;
                      description
                        "match attr type";
                    }
                  }  // list match-attribute
                }  // list match-capability

                list action-capability {
                  description
                    "Action capability";
                  container policy-action-attribute {
                    description
                      "Policy Action attribute  info";
                    container sub-action {
                      when
                        "../action-type = 'sub-action-attribute'" {
                        description
                          "../action_type = 'SubActionAttribute'";
                      }
                      description
                        "sub action";
                      list sub-action-attribute {
                        description "";
                        container action-attribute {
                          description "";
                          leaf policy-action-exec-type {
                            type Policy-action-exec-type-e;
                            description
                              "policy action exec type";
                          }

                          leaf num-instances {
                            type uint32;
                            description
                              "num instances";
                          }
                        }  // container action-attribute

                        leaf sub-action {
                          type uint32;
                          description "";
                        }
                      }  // list sub-action-attribute
                    }  // container sub-action

                    container action-attr {
                      when
                        "../action-type = 'action-attribute'" {
                        description
                          "../action_type = 'ActionAttribute'";
                      }
                      description
                        "action attr";
                      leaf policy-action-exec-type {
                        type Policy-action-exec-type-e;
                        description
                          "policy action exec type";
                      }

                      leaf num-instances {
                        type uint32;
                        description
                          "num instances";
                      }
                    }  // container action-attr

                    leaf action-type {
                      type Policy-action-attr-en;
                      description
                        "action type";
                    }
                  }  // container policy-action-attribute

                  leaf policy-action {
                    type Policy-action-e;
                    description
                      "Policy action ";
                  }
                }  // list action-capability
              }  // list table-capabilty
            }  // container l2l3

            container l3ds {
              description
                "Tablecap for l3ds";
              list table-capabilty {
                description
                  "Table capability";
                container stats-capabilty {
                  description
                    "Stats capabaility";
                  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";
                  }
                }  // container stats-capabilty

                container transient-capability {
                  description
                    "Transient capability";
                  leaf transient {
                    type boolean;
                    description
                      "Table transient support";
                  }
                }  // container transient-capability

                container persistent-capability {
                  description
                    "Persistent capability";
                  leaf persistent {
                    type boolean;
                    description
                      "Table persistent support";
                  }
                }  // container persistent-capability

                container class-capability {
                  description
                    "Class capabaility";
                  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";
                  }
                }  // 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 ";
                  leaf match-capability-type {
                    type Match-cap-e;
                    description "Match type";
                  }

                  list match-attribute {
                    description
                      "Match attribute";
                    container val-attr {
                      when
                        "../match-attr-type = 'value'" {
                        description
                          "../match_attr_type = 'Value'";
                      }
                      description "val attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container val-attr

                    container rng-attr {
                      when
                        "../match-attr-type = 'range'" {
                        description
                          "../match_attr_type = 'Range'";
                      }
                      description "rng attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container rng-attr

                    container mask-attr {
                      when
                        "../match-attr-type = 'mask'" {
                        description
                          "../match_attr_type = 'Mask'";
                      }
                      description
                        "mask attr";
                      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";
                      }
                    }  // container mask-attr

                    leaf match-attr-type {
                      type Match-attr-e;
                      description
                        "match attr type";
                    }
                  }  // list match-attribute
                }  // list match-capability

                list action-capability {
                  description
                    "Action capability";
                  container policy-action-attribute {
                    description
                      "Policy Action attribute  info";
                    container sub-action {
                      when
                        "../action-type = 'sub-action-attribute'" {
                        description
                          "../action_type = 'SubActionAttribute'";
                      }
                      description
                        "sub action";
                      list sub-action-attribute {
                        description "";
                        container action-attribute {
                          description "";
                          leaf policy-action-exec-type {
                            type Policy-action-exec-type-e;
                            description
                              "policy action exec type";
                          }

                          leaf num-instances {
                            type uint32;
                            description
                              "num instances";
                          }
                        }  // container action-attribute

                        leaf sub-action {
                          type uint32;
                          description "";
                        }
                      }  // list sub-action-attribute
                    }  // container sub-action

                    container action-attr {
                      when
                        "../action-type = 'action-attribute'" {
                        description
                          "../action_type = 'ActionAttribute'";
                      }
                      description
                        "action attr";
                      leaf policy-action-exec-type {
                        type Policy-action-exec-type-e;
                        description
                          "policy action exec type";
                      }

                      leaf num-instances {
                        type uint32;
                        description
                          "num instances";
                      }
                    }  // container action-attr

                    leaf action-type {
                      type Policy-action-attr-en;
                      description
                        "action type";
                    }
                  }  // container policy-action-attribute

                  leaf policy-action {
                    type Policy-action-e;
                    description
                      "Policy action ";
                  }
                }  // list action-capability
              }  // list table-capabilty
            }  // container l3ds

            container l3ipv4 {
              description
                "Tablecap for l3ipv4";
              list table-capabilty {
                description
                  "Table capability";
                container stats-capabilty {
                  description
                    "Stats capabaility";
                  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";
                  }
                }  // container stats-capabilty

                container transient-capability {
                  description
                    "Transient capability";
                  leaf transient {
                    type boolean;
                    description
                      "Table transient support";
                  }
                }  // container transient-capability

                container persistent-capability {
                  description
                    "Persistent capability";
                  leaf persistent {
                    type boolean;
                    description
                      "Table persistent support";
                  }
                }  // container persistent-capability

                container class-capability {
                  description
                    "Class capabaility";
                  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";
                  }
                }  // 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 ";
                  leaf match-capability-type {
                    type Match-cap-e;
                    description "Match type";
                  }

                  list match-attribute {
                    description
                      "Match attribute";
                    container val-attr {
                      when
                        "../match-attr-type = 'value'" {
                        description
                          "../match_attr_type = 'Value'";
                      }
                      description "val attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container val-attr

                    container rng-attr {
                      when
                        "../match-attr-type = 'range'" {
                        description
                          "../match_attr_type = 'Range'";
                      }
                      description "rng attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container rng-attr

                    container mask-attr {
                      when
                        "../match-attr-type = 'mask'" {
                        description
                          "../match_attr_type = 'Mask'";
                      }
                      description
                        "mask attr";
                      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";
                      }
                    }  // container mask-attr

                    leaf match-attr-type {
                      type Match-attr-e;
                      description
                        "match attr type";
                    }
                  }  // list match-attribute
                }  // list match-capability

                list action-capability {
                  description
                    "Action capability";
                  container policy-action-attribute {
                    description
                      "Policy Action attribute  info";
                    container sub-action {
                      when
                        "../action-type = 'sub-action-attribute'" {
                        description
                          "../action_type = 'SubActionAttribute'";
                      }
                      description
                        "sub action";
                      list sub-action-attribute {
                        description "";
                        container action-attribute {
                          description "";
                          leaf policy-action-exec-type {
                            type Policy-action-exec-type-e;
                            description
                              "policy action exec type";
                          }

                          leaf num-instances {
                            type uint32;
                            description
                              "num instances";
                          }
                        }  // container action-attribute

                        leaf sub-action {
                          type uint32;
                          description "";
                        }
                      }  // list sub-action-attribute
                    }  // container sub-action

                    container action-attr {
                      when
                        "../action-type = 'action-attribute'" {
                        description
                          "../action_type = 'ActionAttribute'";
                      }
                      description
                        "action attr";
                      leaf policy-action-exec-type {
                        type Policy-action-exec-type-e;
                        description
                          "policy action exec type";
                      }

                      leaf num-instances {
                        type uint32;
                        description
                          "num instances";
                      }
                    }  // container action-attr

                    leaf action-type {
                      type Policy-action-attr-en;
                      description
                        "action type";
                    }
                  }  // container policy-action-attribute

                  leaf policy-action {
                    type Policy-action-e;
                    description
                      "Policy action ";
                  }
                }  // list action-capability
              }  // list table-capabilty
            }  // container l3ipv4

            container qos-in {
              description
                "Tablecap for qos-in";
              list table-capabilty {
                description
                  "Table capability";
                container stats-capabilty {
                  description
                    "Stats capabaility";
                  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";
                  }
                }  // container stats-capabilty

                container transient-capability {
                  description
                    "Transient capability";
                  leaf transient {
                    type boolean;
                    description
                      "Table transient support";
                  }
                }  // container transient-capability

                container persistent-capability {
                  description
                    "Persistent capability";
                  leaf persistent {
                    type boolean;
                    description
                      "Table persistent support";
                  }
                }  // container persistent-capability

                container class-capability {
                  description
                    "Class capabaility";
                  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";
                  }
                }  // 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 ";
                  leaf match-capability-type {
                    type Match-cap-e;
                    description "Match type";
                  }

                  list match-attribute {
                    description
                      "Match attribute";
                    container val-attr {
                      when
                        "../match-attr-type = 'value'" {
                        description
                          "../match_attr_type = 'Value'";
                      }
                      description "val attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container val-attr

                    container rng-attr {
                      when
                        "../match-attr-type = 'range'" {
                        description
                          "../match_attr_type = 'Range'";
                      }
                      description "rng attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container rng-attr

                    container mask-attr {
                      when
                        "../match-attr-type = 'mask'" {
                        description
                          "../match_attr_type = 'Mask'";
                      }
                      description
                        "mask attr";
                      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";
                      }
                    }  // container mask-attr

                    leaf match-attr-type {
                      type Match-attr-e;
                      description
                        "match attr type";
                    }
                  }  // list match-attribute
                }  // list match-capability

                list action-capability {
                  description
                    "Action capability";
                  container policy-action-attribute {
                    description
                      "Policy Action attribute  info";
                    container sub-action {
                      when
                        "../action-type = 'sub-action-attribute'" {
                        description
                          "../action_type = 'SubActionAttribute'";
                      }
                      description
                        "sub action";
                      list sub-action-attribute {
                        description "";
                        container action-attribute {
                          description "";
                          leaf policy-action-exec-type {
                            type Policy-action-exec-type-e;
                            description
                              "policy action exec type";
                          }

                          leaf num-instances {
                            type uint32;
                            description
                              "num instances";
                          }
                        }  // container action-attribute

                        leaf sub-action {
                          type uint32;
                          description "";
                        }
                      }  // list sub-action-attribute
                    }  // container sub-action

                    container action-attr {
                      when
                        "../action-type = 'action-attribute'" {
                        description
                          "../action_type = 'ActionAttribute'";
                      }
                      description
                        "action attr";
                      leaf policy-action-exec-type {
                        type Policy-action-exec-type-e;
                        description
                          "policy action exec type";
                      }

                      leaf num-instances {
                        type uint32;
                        description
                          "num instances";
                      }
                    }  // container action-attr

                    leaf action-type {
                      type Policy-action-attr-en;
                      description
                        "action type";
                    }
                  }  // container policy-action-attribute

                  leaf policy-action {
                    type Policy-action-e;
                    description
                      "Policy action ";
                  }
                }  // list action-capability
              }  // list table-capabilty
            }  // container qos-in

            container qos-out {
              description
                "Tablecap for qos-out";
              list table-capabilty {
                description
                  "Table capability";
                container stats-capabilty {
                  description
                    "Stats capabaility";
                  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";
                  }
                }  // container stats-capabilty

                container transient-capability {
                  description
                    "Transient capability";
                  leaf transient {
                    type boolean;
                    description
                      "Table transient support";
                  }
                }  // container transient-capability

                container persistent-capability {
                  description
                    "Persistent capability";
                  leaf persistent {
                    type boolean;
                    description
                      "Table persistent support";
                  }
                }  // container persistent-capability

                container class-capability {
                  description
                    "Class capabaility";
                  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";
                  }
                }  // 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 ";
                  leaf match-capability-type {
                    type Match-cap-e;
                    description "Match type";
                  }

                  list match-attribute {
                    description
                      "Match attribute";
                    container val-attr {
                      when
                        "../match-attr-type = 'value'" {
                        description
                          "../match_attr_type = 'Value'";
                      }
                      description "val attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container val-attr

                    container rng-attr {
                      when
                        "../match-attr-type = 'range'" {
                        description
                          "../match_attr_type = 'Range'";
                      }
                      description "rng attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container rng-attr

                    container mask-attr {
                      when
                        "../match-attr-type = 'mask'" {
                        description
                          "../match_attr_type = 'Mask'";
                      }
                      description
                        "mask attr";
                      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";
                      }
                    }  // container mask-attr

                    leaf match-attr-type {
                      type Match-attr-e;
                      description
                        "match attr type";
                    }
                  }  // list match-attribute
                }  // list match-capability

                list action-capability {
                  description
                    "Action capability";
                  container policy-action-attribute {
                    description
                      "Policy Action attribute  info";
                    container sub-action {
                      when
                        "../action-type = 'sub-action-attribute'" {
                        description
                          "../action_type = 'SubActionAttribute'";
                      }
                      description
                        "sub action";
                      list sub-action-attribute {
                        description "";
                        container action-attribute {
                          description "";
                          leaf policy-action-exec-type {
                            type Policy-action-exec-type-e;
                            description
                              "policy action exec type";
                          }

                          leaf num-instances {
                            type uint32;
                            description
                              "num instances";
                          }
                        }  // container action-attribute

                        leaf sub-action {
                          type uint32;
                          description "";
                        }
                      }  // list sub-action-attribute
                    }  // container sub-action

                    container action-attr {
                      when
                        "../action-type = 'action-attribute'" {
                        description
                          "../action_type = 'ActionAttribute'";
                      }
                      description
                        "action attr";
                      leaf policy-action-exec-type {
                        type Policy-action-exec-type-e;
                        description
                          "policy action exec type";
                      }

                      leaf num-instances {
                        type uint32;
                        description
                          "num instances";
                      }
                    }  // container action-attr

                    leaf action-type {
                      type Policy-action-attr-en;
                      description
                        "action type";
                    }
                  }  // container policy-action-attribute

                  leaf policy-action {
                    type Policy-action-e;
                    description
                      "Policy action ";
                  }
                }  // list action-capability
              }  // list table-capabilty
            }  // container qos-out

            container traffic-in {
              description
                "Tablecap for traffic-in";
              list table-capabilty {
                description
                  "Table capability";
                container stats-capabilty {
                  description
                    "Stats capabaility";
                  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";
                  }
                }  // container stats-capabilty

                container transient-capability {
                  description
                    "Transient capability";
                  leaf transient {
                    type boolean;
                    description
                      "Table transient support";
                  }
                }  // container transient-capability

                container persistent-capability {
                  description
                    "Persistent capability";
                  leaf persistent {
                    type boolean;
                    description
                      "Table persistent support";
                  }
                }  // container persistent-capability

                container class-capability {
                  description
                    "Class capabaility";
                  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";
                  }
                }  // 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 ";
                  leaf match-capability-type {
                    type Match-cap-e;
                    description "Match type";
                  }

                  list match-attribute {
                    description
                      "Match attribute";
                    container val-attr {
                      when
                        "../match-attr-type = 'value'" {
                        description
                          "../match_attr_type = 'Value'";
                      }
                      description "val attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container val-attr

                    container rng-attr {
                      when
                        "../match-attr-type = 'range'" {
                        description
                          "../match_attr_type = 'Range'";
                      }
                      description "rng attr";
                      leaf minimum {
                        type uint32;
                        description
                          "Minimum value for a match type";
                      }

                      leaf maximum {
                        type uint32;
                        description
                          "Maximum value for a match type";
                      }
                    }  // container rng-attr

                    container mask-attr {
                      when
                        "../match-attr-type = 'mask'" {
                        description
                          "../match_attr_type = 'Mask'";
                      }
                      description
                        "mask attr";
                      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";
                      }
                    }  // container mask-attr

                    leaf match-attr-type {
                      type Match-attr-e;
                      description
                        "match attr type";
                    }
                  }  // list match-attribute
                }  // list match-capability

                list action-capability {
                  description
                    "Action capability";
                  container policy-action-attribute {
                    description
                      "Policy Action attribute  info";
                    container sub-action {
                      when
                        "../action-type = 'sub-action-attribute'" {
                        description
                          "../action_type = 'SubActionAttribute'";
                      }
                      description
                        "sub action";
                      list sub-action-attribute {
                        description "";
                        container action-attribute {
                          description "";
                          leaf policy-action-exec-type {
                            type Policy-action-exec-type-e;
                            description
                              "policy action exec type";
                          }

                          leaf num-instances {
                            type uint32;
                            description
                              "num instances";
                          }
                        }  // container action-attribute

                        leaf sub-action {
                          type uint32;
                          description "";
                        }
                      }  // list sub-action-attribute
                    }  // container sub-action

                    container action-attr {
                      when
                        "../action-type = 'action-attribute'" {
                        description
                          "../action_type = 'ActionAttribute'";
                      }
                      description
                        "action attr";
                      leaf policy-action-exec-type {
                        type Policy-action-exec-type-e;
                        description
                          "policy action exec type";
                      }

                      leaf num-instances {
                        type uint32;
                        description
                          "num instances";
                      }
                    }  // container action-attr

                    leaf action-type {
                      type Policy-action-attr-en;
                      description
                        "action type";
                    }
                  }  // container policy-action-attribute

                  leaf policy-action {
                    type Policy-action-e;
                    description
                      "Policy action ";
                  }
                }  // list action-capability
              }  // list table-capabilty
            }  // 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";
                  container detail {
                    description
                      "WORD interface name";
                    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";
                      list policy-map-bg {
                        description
                          "policy map bg";
                        container pmap-var-list {
                          description
                            "contains variable argument data";
                          list pmap-var-list-arr {
                            description
                              "pmap var list arr";
                            container val {
                              description
                                "val";
                              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";
                              }
                            }  // container val

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

                            leaf id {
                              type uint32;
                              description
                                "id";
                            }
                          }  // list pmap-var-list-arr
                        }  // container pmap-var-list

                        container event-infop {
                          description
                            "event infop";
                          list policy-event-info-bg {
                            description
                              "policy event info bg";
                            container class-infop {
                              description
                                "class infop";
                              list policy-class-info-bg {
                                description
                                  "policy class info bg";
                                container clmp-p {
                                  description
                                    "clmp p";
                                  list class-map-bg {
                                    description
                                      "class map bg";
                                    container match-infop {
                                      description
                                        "Pointer to the first Match info";
                                      list class-match-info-st {
                                        description
                                          "class match info st";
                                        container match-data {
                                          description
                                            "Match criteria";
                                          container ipv4-dscp {
                                            when
                                              "../type = 'match-type-ipv4-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                            }
                                            description
                                              "IPv4 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv4-dscp

                                          container ipv6-dscp {
                                            when
                                              "../type = 'match-type-ipv6-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                            }
                                            description
                                              "IPv6 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv6-dscp

                                          container dscp {
                                            when
                                              "../type = 'match-type-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DSCP'";
                                            }
                                            description
                                              "Match DSCP range array";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container dscp

                                          container ipv4-prec {
                                            when
                                              "../type = 'match-type-ipv4-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_PREC'";
                                            }
                                            description
                                              "IPv4 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv4-prec

                                          container ipv6-prec {
                                            when
                                              "../type = 'match-type-ipv6-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_PREC'";
                                            }
                                            description
                                              "IPv6 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv6-prec

                                          container prec {
                                            when
                                              "../type = 'match-type-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_PREC'";
                                            }
                                            description
                                              "Match Precedence array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container prec

                                          container discard-class {
                                            when
                                              "../type = 'match-type-disc-cls'" {
                                              description
                                                "../type = 'MATCH_TYPE_DISC_CLS'";
                                            }
                                            description
                                              "Match Discard Class array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container traffic-class

                                          container proto {
                                            when
                                              "../type = 'match-type-proto'" {
                                              description
                                                "../type = 'MATCH_TYPE_PROTO'";
                                            }
                                            description
                                              "Match Protocol array";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf value {
                                              type uint16;
                                              description
                                                "Value of TCP flag";
                                            }

                                            leaf match-any {
                                              type boolean;
                                              description
                                                "Match any TCP flag bit";
                                            }
                                          }  // container tcp-flag

                                          container icmpv4-type {
                                            when
                                              "../type = 'match-type-icmpv4-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                            }
                                            description
                                              "Match ipv4 icmp type";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list uint32_rng_array {
                                              description
                                                "uint32 rng array";
                                              leaf min {
                                                type uint32;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint32;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint32_rng_array
                                          }  // container mpls-top-label

                                          container cos {
                                            when
                                              "../type = 'match-type-cos'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS'";
                                            }
                                            description
                                              "Match CoS array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos

                                          container cos-inr {
                                            when
                                              "../type = 'match-type-cos-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS_INNER'";
                                            }
                                            description
                                              "Match inner header CoS";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos-inr

                                          container dei {
                                            when
                                              "../type = 'match-type-dei'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI'";
                                            }
                                            description
                                              "Match DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei

                                          container dei-inr {
                                            when
                                              "../type = 'match-type-dei-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI_INNER'";
                                            }
                                            description
                                              "Match inner DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei-inr

                                          container vlan {
                                            when
                                              "../type = 'match-type-vlan'" {
                                              description
                                                "../type = 'MATCH_TYPE_VLAN'";
                                            }
                                            description
                                              "Match VLAN array";
                                            list vlan-id-array {
                                              description
                                                "vlan id array";
                                              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";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            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
                                          }  // container src-mac

                                          container dst-mac {
                                            when
                                              "../type = 'match-type-dst-mac'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_MAC'";
                                            }
                                            description
                                              "Match Destination MAC address";
                                            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
                                          }  // container dst-mac

                                          container atm-clp {
                                            when
                                              "../type = 'match-type-atm-clp'" {
                                              description
                                                "../type = 'MATCH_TYPE_ATM_CLP'";
                                            }
                                            description
                                              "Match ATM CLP level";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container fr-de

                                          container ipv4-acl {
                                            when
                                              "../type = 'match-type-ipv4-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_ACL'";
                                            }
                                            description
                                              "IPv4 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ipv4-acl

                                          container ipv6-acl {
                                            when
                                              "../type = 'match-type-ipv6-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_ACL'";
                                            }
                                            description
                                              "IPv6 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ether-service-acl

                                          container avail-id {
                                            when
                                              "../type = 'match-type-avail-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_AVAIL_ID'";
                                            }
                                            description
                                              "Available Identifiers";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container avail-id

                                          container media-type {
                                            when
                                              "../type = 'match-type-media'" {
                                              description
                                                "../type = 'MATCH_TYPE_MEDIA'";
                                            }
                                            description
                                              "Media Type";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container media-type

                                          container subs-protocol {
                                            when
                                              "../type = 'match-type-subs-protocol'" {
                                              description
                                                "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                            }
                                            description
                                              "Protocol";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container subs-protocol

                                          container dnis {
                                            when
                                              "../type = 'match-type-dnis'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS'";
                                            }
                                            description
                                              "DNIS";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis

                                          container dnis-regex {
                                            when
                                              "../type = 'match-type-dnis-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                            }
                                            description
                                              "DNIS Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis-regex

                                          container domain {
                                            when
                                              "../type = 'match-type-domain'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN'";
                                            }
                                            description
                                              "Domain Name";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain

                                          container domain-regex {
                                            when
                                              "../type = 'match-type-domain-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                            }
                                            description
                                              "Domain Regular Expression";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain-regex

                                          container nas-port {
                                            when
                                              "../type = 'match-type-nas-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_NAS_PORT'";
                                            }
                                            description
                                              "NAS Port";
                                            list nas-port-array {
                                              description
                                                "nas port array";
                                              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";
                                              }
                                            }  // list nas-port-array
                                          }  // container nas-port

                                          container service-name {
                                            when
                                              "../type = 'match-type-service-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                            }
                                            description
                                              "Service Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list mac-addr-array {
                                              description
                                                "mac addr array";
                                              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
                                            }  // list mac-addr-array
                                          }  // container src-addr-mac

                                          container timer {
                                            when
                                              "../type = 'match-type-timer'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER'";
                                            }
                                            description
                                              "Timer";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer

                                          container timer-regexp {
                                            when
                                              "../type = 'match-type-timer-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                            }
                                            description
                                              "Timer Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer-regexp

                                          container tunnel-name {
                                            when
                                              "../type = 'match-type-tunnel-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                            }
                                            description
                                              "Tunnel Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container tunnel-name-regex

                                          container user-name {
                                            when
                                              "../type = 'match-type-user-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_USERNAME'";
                                            }
                                            description
                                              "User Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container unauth-domain-regex

                                          container vendor-id {
                                            when
                                              "../type = 'match-type-vendor-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_VENDOR_ID'";
                                            }
                                            description
                                              "Vendor ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container vendor-id-regex

                                          container access-interface {
                                            when
                                              "../type = 'match-type-access-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                            }
                                            description
                                              "Access interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container access-interface

                                          container input-interface {
                                            when
                                              "../type = 'match-type-input-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                            }
                                            description
                                              "Input interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container input-interface

                                          container ethertype {
                                            when
                                              "../type = 'match-type-ether-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ETHERTYPE'";
                                            }
                                            description
                                              "Ethernet type";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            container flow-keys {
                                              description
                                                "flow keys";
                                              leaf keys {
                                                type yang:hex-string;
                                                description
                                                  "keys";
                                              }

                                              leaf num {
                                                type uint8;
                                                description
                                                  "num";
                                              }
                                            }  // 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)";
                                            }
                                          }  // 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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container circuit-id-regex

                                          container remote-id {
                                            when
                                              "../type = 'match-type-remote-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_REMOTE_ID'";
                                            }
                                            description
                                              "Remote ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container remote-id-regex

                                          container src-port {
                                            when
                                              "../type = 'match-type-src-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_SRC_PORT'";
                                            }
                                            description
                                              "Source port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint16_rng_array
                                          }  // container src-port

                                          container dst-port {
                                            when
                                              "../type = 'match-type-dst-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_PORT'";
                                            }
                                            description
                                              "Destination port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                          }
                                        }  // container match-data

                                        leaf flags {
                                          type uint32;
                                          description
                                            "Flags";
                                        }
                                      }  // list 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
                                }  // container clmp-p

                                container act-infop {
                                  description
                                    "act infop";
                                  list policy-action-info-st {
                                    description
                                      "policy action info st";
                                    container actp {
                                      description
                                        "actp";
                                      container mark {
                                        when
                                          "../type = 'policy-action-mark'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK'";
                                        }
                                        description
                                          "mark";
                                        list action-mark-info {
                                          description
                                            "action mark info";
                                          leaf type {
                                            type Mark-type-en;
                                            description
                                              "type";
                                          }

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

                                          leaf value {
                                            type uint16;
                                            description
                                              "value";
                                          }
                                        }  // list action-mark-info
                                      }  // container mark

                                      container mark2 {
                                        when
                                          "../type = 'policy-action-mark2'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK2'";
                                        }
                                        description
                                          "mark2";
                                        list action-mark2-info {
                                          description
                                            "action mark2 info";
                                          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";
                                          }
                                        }  // list action-mark2-info
                                      }  // container mark2

                                      container wred {
                                        when
                                          "../type = 'policy-action-wred'" {
                                          description
                                            "../type = 'POLICY_ACTION_WRED'";
                                        }
                                        description
                                          "wred";
                                        list action-wred-info {
                                          description
                                            "action wred info";
                                          container match-ranges {
                                            description
                                              "match ranges";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-ranges

                                          container min-threshold {
                                            description
                                              "min threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container min-threshold

                                          container max-threshold {
                                            description
                                              "max threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // 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";
                                          }
                                        }  // list action-wred-info
                                      }  // container wred

                                      container encap {
                                        when
                                          "../type = 'policy-action-encap-seq'" {
                                          description
                                            "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                        }
                                        description
                                          "encap";
                                        leaf seq {
                                          type uint8;
                                          description
                                            "seq";
                                        }
                                      }  // container encap

                                      container prio {
                                        when
                                          "../type = 'policy-action-priority'" {
                                          description
                                            "../type = 'POLICY_ACTION_PRIORITY'";
                                        }
                                        description
                                          "prio";
                                        leaf prio-lvl {
                                          type uint32;
                                          description
                                            "prio lvl";
                                        }
                                      }  // container prio

                                      container bwrem {
                                        when
                                          "../type = 'policy-action-bw-remaining'" {
                                          description
                                            "../type = 'POLICY_ACTION_BW_REMAINING'";
                                        }
                                        description
                                          "bwrem";
                                        container bwrem {
                                          description
                                            "bwrem";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bwrem
                                      }  // container bwrem

                                      container min-bw {
                                        when
                                          "../type = 'policy-action-min-bw'" {
                                          description
                                            "../type = 'POLICY_ACTION_MIN_BW'";
                                        }
                                        description
                                          "min bw";
                                        container bw {
                                          description
                                            "bw";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bw
                                      }  // container min-bw

                                      container authen-aaa {
                                        when
                                          "../type = 'policy-action-authenticate-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                        }
                                        description
                                          "authen aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf authen-password {
                                          type string;
                                          description
                                            "authen password";
                                        }
                                      }  // container authen-aaa

                                      container collect-id {
                                        when
                                          "../type = 'policy-action-collect-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_COLLECT_ID'";
                                        }
                                        description
                                          "collect id";
                                        leaf id {
                                          type Identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container collect-id

                                      container decode-id {
                                        when
                                          "../type = 'policy-action-decode-identifier'" {
                                          description
                                            "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                        }
                                        description
                                          "decode id";
                                        leaf id {
                                          type Decode-identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf format-name {
                                          type string;
                                          description
                                            "format name";
                                        }
                                      }  // container decode-id

                                      container set-timer {
                                        when
                                          "../type = 'policy-action-set-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_SET_TIMER'";
                                        }
                                        description
                                          "set timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }

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

                                        leaf absolute-time {
                                          type string;
                                          description
                                            "absolute time";
                                        }
                                      }  // container set-timer

                                      container stop-timer {
                                        when
                                          "../type = 'policy-action-stop-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_STOP_TIMER'";
                                        }
                                        description
                                          "stop timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }
                                      }  // 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";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container acct-aaa-list

                                      container query-ancp {
                                        when
                                          "../type = 'policy-action-query-ancp'" {
                                          description
                                            "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                        }
                                        description
                                          "query ancp";
                                        leaf enable {
                                          type boolean;
                                          description
                                            "enable";
                                        }
                                      }  // container query-ancp

                                      container prepaid-cfg {
                                        when
                                          "../type = 'policy-action-prepaid-config'" {
                                          description
                                            "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                        }
                                        description
                                          "prepaid cfg";
                                        leaf prepaid-config-profile-name {
                                          type string;
                                          description
                                            "prepaid config profile name";
                                        }
                                      }  // container prepaid-cfg

                                      container timeout-idle {
                                        when
                                          "../type = 'policy-action-timeout-idle'" {
                                          description
                                            "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                        }
                                        description
                                          "timeout idle";
                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container timeout-idle

                                      container proxy-aaa {
                                        when
                                          "../type = 'policy-action-proxy-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_PROXY_AAA'";
                                        }
                                        description
                                          "proxy aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container proxy-aaa

                                      container act-template {
                                        when
                                          "../type = 'policy-action-template-activate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                        }
                                        description
                                          "act template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container act-template

                                      container deact-template {
                                        when
                                          "../type = 'policy-action-template-deactivate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                        }
                                        description
                                          "deact template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container deact-template

                                      container qlimit {
                                        when
                                          "../type = 'policy-action-q-limit'" {
                                          description
                                            "../type = 'POLICY_ACTION_Q_LIMIT'";
                                        }
                                        description
                                          "qlimit";
                                        list action-qlimit-info-array {
                                          description
                                            "action qlimit info array";
                                          container qlim {
                                            description
                                              "qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container qlim

                                          container atmclp-qlim {
                                            description
                                              "atmclp qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container atmclp-qlim

                                          container match-values {
                                            description
                                              "match values";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-values

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

                                          leaf qlimit-flags {
                                            type uint32;
                                            description
                                              "qlimit flags";
                                          }
                                        }  // list 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";
                                        leaf action {
                                          type Acct-en;
                                          description
                                            "action";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container accounting-event-aaa

                                      container authorize-id {
                                        when
                                          "../type = 'policy-action-authorize-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                        }
                                        description
                                          "authorize id";
                                        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";
                                        }
                                      }  // container authorize-id

                                      container afm-react {
                                        when
                                          "../type = 'policy-action-afmon-react'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_REACT'";
                                        }
                                        description
                                          "afm react";
                                        list action-afmon-react-info {
                                          description
                                            "action afmon react info";
                                          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";
                                          }
                                        }  // list action-afmon-react-info
                                      }  // container afm-react

                                      container httpr {
                                        when
                                          "../type = 'policy-action-httpr'" {
                                          description
                                            "../type = 'POLICY_ACTION_HTTPR'";
                                        }
                                        description
                                          "httpr";
                                        leaf redirect-url {
                                          type string;
                                          description
                                            "redirect url";
                                        }
                                      }  // container httpr

                                      container punt {
                                        when
                                          "../type = 'policy-action-punt'" {
                                          description
                                            "../type = 'POLICY_ACTION_PUNT'";
                                        }
                                        description
                                          "punt";
                                        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";
                                        }
                                      }  // container punt

                                      container copy {
                                        when
                                          "../type = 'policy-action-copy'" {
                                          description
                                            "../type = 'POLICY_ACTION_COPY'";
                                        }
                                        description
                                          "copy";
                                        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";
                                        }
                                      }  // container copy

                                      container sfrag {
                                        when
                                          "../type = 'policy-action-sfrag'" {
                                          description
                                            "../type = 'POLICY_ACTION_SFRAG'";
                                        }
                                        description
                                          "sfrag";
                                        leaf name {
                                          type string;
                                          description
                                            "Service Fragment Name";
                                        }
                                      }  // container sfrag

                                      container redirect {
                                        when
                                          "../type = 'policy-action-redirect'" {
                                          description
                                            "../type = 'POLICY_ACTION_REDIRECT'";
                                        }
                                        description
                                          "redirect";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf type {
                                          type Redirect-type-e;
                                          description
                                            "type";
                                        }
                                      }  // container redirect

                                      container out-intf {
                                        when
                                          "../type = 'policy-action-output-interface'" {
                                          description
                                            "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                        }
                                        description
                                          "out intf";
                                        leaf out-ifname {
                                          type string;
                                          description
                                            "output interface name";
                                        }
                                      }  // container out-intf

                                      container serv-func {
                                        when
                                          "../type = 'policy-action-service-function-path'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                        }
                                        description
                                          "serv func";
                                        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";
                                        }
                                      }  // 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";
                                        list action-police-info-st {
                                          description
                                            "action police info array";
                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

                                          container burst {
                                            description
                                              "burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container burst

                                          container peak-rate {
                                            description
                                              "peak rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-rate

                                          container peak-burst {
                                            description
                                              "peak burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-burst

                                          container cdvt {
                                            description
                                              "cdvt";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container cdvt

                                          container conform-actns {
                                            description
                                              "conform actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container conform-actns

                                          container exceed-actns {
                                            description
                                              "exceed actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container exceed-actns

                                          container violate-actns {
                                            description
                                              "violate actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container violate-actns

                                          container confclass-p {
                                            description
                                              "confclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // container confclass-p

                                          container excdclass-p {
                                            description
                                              "excdclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // 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";
                                          }
                                        }  // list action-police-info-st
                                      }  // container police

                                      container shape {
                                        when
                                          "../type = 'policy-action-shape'" {
                                          description
                                            "../type = 'POLICY_ACTION_SHAPE'";
                                        }
                                        description
                                          "shape";
                                        list action-shape-info-st {
                                          description
                                            "action police info array";
                                          container bw {
                                            description
                                              "bw";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container bw

                                          container be {
                                            description
                                              "be";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container be
                                        }  // list action-shape-info-st
                                      }  // container shape

                                      container child-policy {
                                        when
                                          "../type = 'policy-action-serv-pol'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERV_POL'";
                                        }
                                        description
                                          "child policy";
                                        list action-policy-info-st {
                                          description
                                            "child policy info";
                                          container info {
                                            when
                                              "../enc = 'policy-obj-enc-name'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_NAME'";
                                            }
                                            description
                                              "info";
                                            leaf name {
                                              type Policy-map-name;
                                              description
                                                "name";
                                            }

                                            leaf type {
                                              type Policy-map-type-en;
                                              description
                                                "type";
                                            }
                                          }  // container info

                                          container hd-info {
                                            when
                                              "../enc = 'policy-obj-enc-hdl'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_HDL'";
                                            }
                                            description
                                              "hd info";
                                            container data-hd {
                                              description
                                                "data hd";
                                              list policy-map-name-type {
                                                description
                                                  "policy map type and name";
                                                leaf name {
                                                  type Policy-map-name;
                                                  description
                                                    "name";
                                                }

                                                leaf type {
                                                  type Policy-map-type-en;
                                                  description
                                                    "type";
                                                }
                                              }  // list policy-map-name-type
                                            }  // container data-hd
                                          }  // container hd-info

                                          leaf enc {
                                            type Policy-obj-enc-en;
                                            description
                                              "enc";
                                          }
                                        }  // list action-policy-info-st
                                      }  // container child-policy

                                      container cac {
                                        when
                                          "../type = 'policy-action-cac'" {
                                          description
                                            "../type = 'POLICY_ACTION_CAC'";
                                        }
                                        description
                                          "cac";
                                        list action-cac-info-st {
                                          description
                                            "action cac info st";
                                          container flow-rate {
                                            description
                                              "flow rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container flow-rate

                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

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

                                          leaf idle-timeout {
                                            type uint16;
                                            description
                                              "idle timeout";
                                          }
                                        }  // list action-cac-info-st
                                      }  // container cac

                                      container pfc {
                                        when
                                          "../type = 'policy-action-pfc'" {
                                          description
                                            "../type = 'POLICY_ACTION_PFC'";
                                        }
                                        description
                                          "pfc";
                                        list action-pfc-info-st {
                                          description
                                            "action pfc info st";
                                          container buffer-size {
                                            description
                                              "buffer size";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container buffer-size

                                          container pause-threshold {
                                            description
                                              "pause threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container pause-threshold

                                          container resume-threshold {
                                            description
                                              "resume threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container resume-threshold

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

                                          leaf buffer-size-flag {
                                            type uint32;
                                            description
                                              "buffer size flag";
                                          }
                                        }  // list action-pfc-info-st
                                      }  // container pfc

                                      container flow-parm {
                                        when
                                          "../type = 'policy-action-afmon-flow-parm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                        }
                                        description
                                          "flow parm";
                                        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";
                                        }
                                      }  // container flow-parm

                                      container ipcbr {
                                        when
                                          "../type = 'policy-action-afmon-ipcbr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                        }
                                        description
                                          "ipcbr";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container ip-bit-rate

                                        container media-bit-rate {
                                          description
                                            "media data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container ipcbr

                                      container rtp {
                                        when
                                          "../type = 'policy-action-afmon-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                        }
                                        description
                                          "rtp";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp

                                      container rtp-mmr {
                                        when
                                          "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                        }
                                        description
                                          "rtp mmr";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp-voice

                                      container mdi {
                                        when
                                          "../type = 'policy-action-afmon-mdi-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                        }
                                        description
                                          "mdi";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi

                                      container mdi-rtp {
                                        when
                                          "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                        }
                                        description
                                          "mdi rtp";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi-rtp

                                      container fmm {
                                        when
                                          "../type = 'policy-action-afmon-fmm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FMM'";
                                        }
                                        description
                                          "fmm";
                                        leaf fmm-name {
                                          type string {
                                            length
                                              "0..33";
                                          }
                                          description
                                            "flow monitor name";
                                        }
                                      }  // container fmm

                                      container pbf {
                                        when
                                          "../type = 'policy-action-pbr-next-hop'" {
                                          description
                                            "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                        }
                                        description
                                          "pbf";
                                        list action-pbf-info-array {
                                          description
                                            "action pbf info array";
                                          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";
                                          }
                                        }  // list action-pbf-info-array
                                      }  // container pbf

                                      container ipv4-nh {
                                        when
                                          "../type = 'policy-action-ipv4-nh'" {
                                          description
                                            "../type = 'POLICY_ACTION_IPV4_NH'";
                                        }
                                        description
                                          "ipv4 nh";
                                        list action-ipv4-nh-info-array {
                                          description
                                            "action ipv4 nh info array";
                                          leaf ipv4-nh-addr {
                                            type inet:ipv4-address;
                                            description
                                              "nh addr";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                        list action-ipv6-nh-info-array {
                                          description
                                            "action ipv6 nh info array";
                                          leaf ipv6-nh-addr {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 Address";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                      }
                                    }  // container actp

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

                                    leaf flags {
                                      type uint16;
                                      description
                                        "flags";
                                    }
                                  }  // list policy-action-info-st
                                }  // container act-infop

                                container nlri-infop {
                                  description
                                    "nlri info pointer";
                                  container nlri {
                                    description
                                      "nlri value";
                                    leaf-list uint8_array {
                                      type uint8;
                                      description
                                        "uint8 array";
                                    }
                                  }  // container nlri
                                }  // 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
                            }  // 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
                        }  // 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
                    }  // list pmaps

                    list pmap-var-list {
                      description
                        "pmap var list";
                      list var-list {
                        description
                          "var list";
                        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";
                        }
                      }  // list var-list
                    }  // list pmap-var-list
                  }  // container detail
                }  // container input

                container output {
                  description
                    "Output direction table";
                  container detail {
                    description
                      "WORD interface name";
                    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";
                      list policy-map-bg {
                        description
                          "policy map bg";
                        container pmap-var-list {
                          description
                            "contains variable argument data";
                          list pmap-var-list-arr {
                            description
                              "pmap var list arr";
                            container val {
                              description
                                "val";
                              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";
                              }
                            }  // container val

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

                            leaf id {
                              type uint32;
                              description
                                "id";
                            }
                          }  // list pmap-var-list-arr
                        }  // container pmap-var-list

                        container event-infop {
                          description
                            "event infop";
                          list policy-event-info-bg {
                            description
                              "policy event info bg";
                            container class-infop {
                              description
                                "class infop";
                              list policy-class-info-bg {
                                description
                                  "policy class info bg";
                                container clmp-p {
                                  description
                                    "clmp p";
                                  list class-map-bg {
                                    description
                                      "class map bg";
                                    container match-infop {
                                      description
                                        "Pointer to the first Match info";
                                      list class-match-info-st {
                                        description
                                          "class match info st";
                                        container match-data {
                                          description
                                            "Match criteria";
                                          container ipv4-dscp {
                                            when
                                              "../type = 'match-type-ipv4-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                            }
                                            description
                                              "IPv4 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv4-dscp

                                          container ipv6-dscp {
                                            when
                                              "../type = 'match-type-ipv6-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                            }
                                            description
                                              "IPv6 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv6-dscp

                                          container dscp {
                                            when
                                              "../type = 'match-type-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DSCP'";
                                            }
                                            description
                                              "Match DSCP range array";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container dscp

                                          container ipv4-prec {
                                            when
                                              "../type = 'match-type-ipv4-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_PREC'";
                                            }
                                            description
                                              "IPv4 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv4-prec

                                          container ipv6-prec {
                                            when
                                              "../type = 'match-type-ipv6-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_PREC'";
                                            }
                                            description
                                              "IPv6 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv6-prec

                                          container prec {
                                            when
                                              "../type = 'match-type-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_PREC'";
                                            }
                                            description
                                              "Match Precedence array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container prec

                                          container discard-class {
                                            when
                                              "../type = 'match-type-disc-cls'" {
                                              description
                                                "../type = 'MATCH_TYPE_DISC_CLS'";
                                            }
                                            description
                                              "Match Discard Class array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container traffic-class

                                          container proto {
                                            when
                                              "../type = 'match-type-proto'" {
                                              description
                                                "../type = 'MATCH_TYPE_PROTO'";
                                            }
                                            description
                                              "Match Protocol array";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf value {
                                              type uint16;
                                              description
                                                "Value of TCP flag";
                                            }

                                            leaf match-any {
                                              type boolean;
                                              description
                                                "Match any TCP flag bit";
                                            }
                                          }  // container tcp-flag

                                          container icmpv4-type {
                                            when
                                              "../type = 'match-type-icmpv4-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                            }
                                            description
                                              "Match ipv4 icmp type";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list uint32_rng_array {
                                              description
                                                "uint32 rng array";
                                              leaf min {
                                                type uint32;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint32;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint32_rng_array
                                          }  // container mpls-top-label

                                          container cos {
                                            when
                                              "../type = 'match-type-cos'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS'";
                                            }
                                            description
                                              "Match CoS array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos

                                          container cos-inr {
                                            when
                                              "../type = 'match-type-cos-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS_INNER'";
                                            }
                                            description
                                              "Match inner header CoS";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos-inr

                                          container dei {
                                            when
                                              "../type = 'match-type-dei'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI'";
                                            }
                                            description
                                              "Match DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei

                                          container dei-inr {
                                            when
                                              "../type = 'match-type-dei-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI_INNER'";
                                            }
                                            description
                                              "Match inner DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei-inr

                                          container vlan {
                                            when
                                              "../type = 'match-type-vlan'" {
                                              description
                                                "../type = 'MATCH_TYPE_VLAN'";
                                            }
                                            description
                                              "Match VLAN array";
                                            list vlan-id-array {
                                              description
                                                "vlan id array";
                                              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";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            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
                                          }  // container src-mac

                                          container dst-mac {
                                            when
                                              "../type = 'match-type-dst-mac'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_MAC'";
                                            }
                                            description
                                              "Match Destination MAC address";
                                            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
                                          }  // container dst-mac

                                          container atm-clp {
                                            when
                                              "../type = 'match-type-atm-clp'" {
                                              description
                                                "../type = 'MATCH_TYPE_ATM_CLP'";
                                            }
                                            description
                                              "Match ATM CLP level";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container fr-de

                                          container ipv4-acl {
                                            when
                                              "../type = 'match-type-ipv4-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_ACL'";
                                            }
                                            description
                                              "IPv4 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ipv4-acl

                                          container ipv6-acl {
                                            when
                                              "../type = 'match-type-ipv6-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_ACL'";
                                            }
                                            description
                                              "IPv6 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ether-service-acl

                                          container avail-id {
                                            when
                                              "../type = 'match-type-avail-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_AVAIL_ID'";
                                            }
                                            description
                                              "Available Identifiers";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container avail-id

                                          container media-type {
                                            when
                                              "../type = 'match-type-media'" {
                                              description
                                                "../type = 'MATCH_TYPE_MEDIA'";
                                            }
                                            description
                                              "Media Type";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container media-type

                                          container subs-protocol {
                                            when
                                              "../type = 'match-type-subs-protocol'" {
                                              description
                                                "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                            }
                                            description
                                              "Protocol";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container subs-protocol

                                          container dnis {
                                            when
                                              "../type = 'match-type-dnis'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS'";
                                            }
                                            description
                                              "DNIS";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis

                                          container dnis-regex {
                                            when
                                              "../type = 'match-type-dnis-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                            }
                                            description
                                              "DNIS Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis-regex

                                          container domain {
                                            when
                                              "../type = 'match-type-domain'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN'";
                                            }
                                            description
                                              "Domain Name";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain

                                          container domain-regex {
                                            when
                                              "../type = 'match-type-domain-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                            }
                                            description
                                              "Domain Regular Expression";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain-regex

                                          container nas-port {
                                            when
                                              "../type = 'match-type-nas-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_NAS_PORT'";
                                            }
                                            description
                                              "NAS Port";
                                            list nas-port-array {
                                              description
                                                "nas port array";
                                              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";
                                              }
                                            }  // list nas-port-array
                                          }  // container nas-port

                                          container service-name {
                                            when
                                              "../type = 'match-type-service-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                            }
                                            description
                                              "Service Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list mac-addr-array {
                                              description
                                                "mac addr array";
                                              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
                                            }  // list mac-addr-array
                                          }  // container src-addr-mac

                                          container timer {
                                            when
                                              "../type = 'match-type-timer'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER'";
                                            }
                                            description
                                              "Timer";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer

                                          container timer-regexp {
                                            when
                                              "../type = 'match-type-timer-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                            }
                                            description
                                              "Timer Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer-regexp

                                          container tunnel-name {
                                            when
                                              "../type = 'match-type-tunnel-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                            }
                                            description
                                              "Tunnel Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container tunnel-name-regex

                                          container user-name {
                                            when
                                              "../type = 'match-type-user-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_USERNAME'";
                                            }
                                            description
                                              "User Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container unauth-domain-regex

                                          container vendor-id {
                                            when
                                              "../type = 'match-type-vendor-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_VENDOR_ID'";
                                            }
                                            description
                                              "Vendor ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container vendor-id-regex

                                          container access-interface {
                                            when
                                              "../type = 'match-type-access-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                            }
                                            description
                                              "Access interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container access-interface

                                          container input-interface {
                                            when
                                              "../type = 'match-type-input-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                            }
                                            description
                                              "Input interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container input-interface

                                          container ethertype {
                                            when
                                              "../type = 'match-type-ether-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ETHERTYPE'";
                                            }
                                            description
                                              "Ethernet type";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            container flow-keys {
                                              description
                                                "flow keys";
                                              leaf keys {
                                                type yang:hex-string;
                                                description
                                                  "keys";
                                              }

                                              leaf num {
                                                type uint8;
                                                description
                                                  "num";
                                              }
                                            }  // 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)";
                                            }
                                          }  // 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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container circuit-id-regex

                                          container remote-id {
                                            when
                                              "../type = 'match-type-remote-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_REMOTE_ID'";
                                            }
                                            description
                                              "Remote ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container remote-id-regex

                                          container src-port {
                                            when
                                              "../type = 'match-type-src-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_SRC_PORT'";
                                            }
                                            description
                                              "Source port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint16_rng_array
                                          }  // container src-port

                                          container dst-port {
                                            when
                                              "../type = 'match-type-dst-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_PORT'";
                                            }
                                            description
                                              "Destination port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                          }
                                        }  // container match-data

                                        leaf flags {
                                          type uint32;
                                          description
                                            "Flags";
                                        }
                                      }  // list 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
                                }  // container clmp-p

                                container act-infop {
                                  description
                                    "act infop";
                                  list policy-action-info-st {
                                    description
                                      "policy action info st";
                                    container actp {
                                      description
                                        "actp";
                                      container mark {
                                        when
                                          "../type = 'policy-action-mark'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK'";
                                        }
                                        description
                                          "mark";
                                        list action-mark-info {
                                          description
                                            "action mark info";
                                          leaf type {
                                            type Mark-type-en;
                                            description
                                              "type";
                                          }

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

                                          leaf value {
                                            type uint16;
                                            description
                                              "value";
                                          }
                                        }  // list action-mark-info
                                      }  // container mark

                                      container mark2 {
                                        when
                                          "../type = 'policy-action-mark2'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK2'";
                                        }
                                        description
                                          "mark2";
                                        list action-mark2-info {
                                          description
                                            "action mark2 info";
                                          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";
                                          }
                                        }  // list action-mark2-info
                                      }  // container mark2

                                      container wred {
                                        when
                                          "../type = 'policy-action-wred'" {
                                          description
                                            "../type = 'POLICY_ACTION_WRED'";
                                        }
                                        description
                                          "wred";
                                        list action-wred-info {
                                          description
                                            "action wred info";
                                          container match-ranges {
                                            description
                                              "match ranges";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-ranges

                                          container min-threshold {
                                            description
                                              "min threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container min-threshold

                                          container max-threshold {
                                            description
                                              "max threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // 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";
                                          }
                                        }  // list action-wred-info
                                      }  // container wred

                                      container encap {
                                        when
                                          "../type = 'policy-action-encap-seq'" {
                                          description
                                            "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                        }
                                        description
                                          "encap";
                                        leaf seq {
                                          type uint8;
                                          description
                                            "seq";
                                        }
                                      }  // container encap

                                      container prio {
                                        when
                                          "../type = 'policy-action-priority'" {
                                          description
                                            "../type = 'POLICY_ACTION_PRIORITY'";
                                        }
                                        description
                                          "prio";
                                        leaf prio-lvl {
                                          type uint32;
                                          description
                                            "prio lvl";
                                        }
                                      }  // container prio

                                      container bwrem {
                                        when
                                          "../type = 'policy-action-bw-remaining'" {
                                          description
                                            "../type = 'POLICY_ACTION_BW_REMAINING'";
                                        }
                                        description
                                          "bwrem";
                                        container bwrem {
                                          description
                                            "bwrem";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bwrem
                                      }  // container bwrem

                                      container min-bw {
                                        when
                                          "../type = 'policy-action-min-bw'" {
                                          description
                                            "../type = 'POLICY_ACTION_MIN_BW'";
                                        }
                                        description
                                          "min bw";
                                        container bw {
                                          description
                                            "bw";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bw
                                      }  // container min-bw

                                      container authen-aaa {
                                        when
                                          "../type = 'policy-action-authenticate-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                        }
                                        description
                                          "authen aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf authen-password {
                                          type string;
                                          description
                                            "authen password";
                                        }
                                      }  // container authen-aaa

                                      container collect-id {
                                        when
                                          "../type = 'policy-action-collect-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_COLLECT_ID'";
                                        }
                                        description
                                          "collect id";
                                        leaf id {
                                          type Identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container collect-id

                                      container decode-id {
                                        when
                                          "../type = 'policy-action-decode-identifier'" {
                                          description
                                            "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                        }
                                        description
                                          "decode id";
                                        leaf id {
                                          type Decode-identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf format-name {
                                          type string;
                                          description
                                            "format name";
                                        }
                                      }  // container decode-id

                                      container set-timer {
                                        when
                                          "../type = 'policy-action-set-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_SET_TIMER'";
                                        }
                                        description
                                          "set timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }

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

                                        leaf absolute-time {
                                          type string;
                                          description
                                            "absolute time";
                                        }
                                      }  // container set-timer

                                      container stop-timer {
                                        when
                                          "../type = 'policy-action-stop-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_STOP_TIMER'";
                                        }
                                        description
                                          "stop timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }
                                      }  // 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";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container acct-aaa-list

                                      container query-ancp {
                                        when
                                          "../type = 'policy-action-query-ancp'" {
                                          description
                                            "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                        }
                                        description
                                          "query ancp";
                                        leaf enable {
                                          type boolean;
                                          description
                                            "enable";
                                        }
                                      }  // container query-ancp

                                      container prepaid-cfg {
                                        when
                                          "../type = 'policy-action-prepaid-config'" {
                                          description
                                            "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                        }
                                        description
                                          "prepaid cfg";
                                        leaf prepaid-config-profile-name {
                                          type string;
                                          description
                                            "prepaid config profile name";
                                        }
                                      }  // container prepaid-cfg

                                      container timeout-idle {
                                        when
                                          "../type = 'policy-action-timeout-idle'" {
                                          description
                                            "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                        }
                                        description
                                          "timeout idle";
                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container timeout-idle

                                      container proxy-aaa {
                                        when
                                          "../type = 'policy-action-proxy-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_PROXY_AAA'";
                                        }
                                        description
                                          "proxy aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container proxy-aaa

                                      container act-template {
                                        when
                                          "../type = 'policy-action-template-activate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                        }
                                        description
                                          "act template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container act-template

                                      container deact-template {
                                        when
                                          "../type = 'policy-action-template-deactivate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                        }
                                        description
                                          "deact template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container deact-template

                                      container qlimit {
                                        when
                                          "../type = 'policy-action-q-limit'" {
                                          description
                                            "../type = 'POLICY_ACTION_Q_LIMIT'";
                                        }
                                        description
                                          "qlimit";
                                        list action-qlimit-info-array {
                                          description
                                            "action qlimit info array";
                                          container qlim {
                                            description
                                              "qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container qlim

                                          container atmclp-qlim {
                                            description
                                              "atmclp qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container atmclp-qlim

                                          container match-values {
                                            description
                                              "match values";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-values

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

                                          leaf qlimit-flags {
                                            type uint32;
                                            description
                                              "qlimit flags";
                                          }
                                        }  // list 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";
                                        leaf action {
                                          type Acct-en;
                                          description
                                            "action";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container accounting-event-aaa

                                      container authorize-id {
                                        when
                                          "../type = 'policy-action-authorize-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                        }
                                        description
                                          "authorize id";
                                        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";
                                        }
                                      }  // container authorize-id

                                      container afm-react {
                                        when
                                          "../type = 'policy-action-afmon-react'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_REACT'";
                                        }
                                        description
                                          "afm react";
                                        list action-afmon-react-info {
                                          description
                                            "action afmon react info";
                                          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";
                                          }
                                        }  // list action-afmon-react-info
                                      }  // container afm-react

                                      container httpr {
                                        when
                                          "../type = 'policy-action-httpr'" {
                                          description
                                            "../type = 'POLICY_ACTION_HTTPR'";
                                        }
                                        description
                                          "httpr";
                                        leaf redirect-url {
                                          type string;
                                          description
                                            "redirect url";
                                        }
                                      }  // container httpr

                                      container punt {
                                        when
                                          "../type = 'policy-action-punt'" {
                                          description
                                            "../type = 'POLICY_ACTION_PUNT'";
                                        }
                                        description
                                          "punt";
                                        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";
                                        }
                                      }  // container punt

                                      container copy {
                                        when
                                          "../type = 'policy-action-copy'" {
                                          description
                                            "../type = 'POLICY_ACTION_COPY'";
                                        }
                                        description
                                          "copy";
                                        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";
                                        }
                                      }  // container copy

                                      container sfrag {
                                        when
                                          "../type = 'policy-action-sfrag'" {
                                          description
                                            "../type = 'POLICY_ACTION_SFRAG'";
                                        }
                                        description
                                          "sfrag";
                                        leaf name {
                                          type string;
                                          description
                                            "Service Fragment Name";
                                        }
                                      }  // container sfrag

                                      container redirect {
                                        when
                                          "../type = 'policy-action-redirect'" {
                                          description
                                            "../type = 'POLICY_ACTION_REDIRECT'";
                                        }
                                        description
                                          "redirect";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf type {
                                          type Redirect-type-e;
                                          description
                                            "type";
                                        }
                                      }  // container redirect

                                      container out-intf {
                                        when
                                          "../type = 'policy-action-output-interface'" {
                                          description
                                            "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                        }
                                        description
                                          "out intf";
                                        leaf out-ifname {
                                          type string;
                                          description
                                            "output interface name";
                                        }
                                      }  // container out-intf

                                      container serv-func {
                                        when
                                          "../type = 'policy-action-service-function-path'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                        }
                                        description
                                          "serv func";
                                        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";
                                        }
                                      }  // 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";
                                        list action-police-info-st {
                                          description
                                            "action police info array";
                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

                                          container burst {
                                            description
                                              "burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container burst

                                          container peak-rate {
                                            description
                                              "peak rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-rate

                                          container peak-burst {
                                            description
                                              "peak burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-burst

                                          container cdvt {
                                            description
                                              "cdvt";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container cdvt

                                          container conform-actns {
                                            description
                                              "conform actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container conform-actns

                                          container exceed-actns {
                                            description
                                              "exceed actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container exceed-actns

                                          container violate-actns {
                                            description
                                              "violate actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container violate-actns

                                          container confclass-p {
                                            description
                                              "confclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // container confclass-p

                                          container excdclass-p {
                                            description
                                              "excdclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // 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";
                                          }
                                        }  // list action-police-info-st
                                      }  // container police

                                      container shape {
                                        when
                                          "../type = 'policy-action-shape'" {
                                          description
                                            "../type = 'POLICY_ACTION_SHAPE'";
                                        }
                                        description
                                          "shape";
                                        list action-shape-info-st {
                                          description
                                            "action police info array";
                                          container bw {
                                            description
                                              "bw";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container bw

                                          container be {
                                            description
                                              "be";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container be
                                        }  // list action-shape-info-st
                                      }  // container shape

                                      container child-policy {
                                        when
                                          "../type = 'policy-action-serv-pol'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERV_POL'";
                                        }
                                        description
                                          "child policy";
                                        list action-policy-info-st {
                                          description
                                            "child policy info";
                                          container info {
                                            when
                                              "../enc = 'policy-obj-enc-name'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_NAME'";
                                            }
                                            description
                                              "info";
                                            leaf name {
                                              type Policy-map-name;
                                              description
                                                "name";
                                            }

                                            leaf type {
                                              type Policy-map-type-en;
                                              description
                                                "type";
                                            }
                                          }  // container info

                                          container hd-info {
                                            when
                                              "../enc = 'policy-obj-enc-hdl'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_HDL'";
                                            }
                                            description
                                              "hd info";
                                            container data-hd {
                                              description
                                                "data hd";
                                              list policy-map-name-type {
                                                description
                                                  "policy map type and name";
                                                leaf name {
                                                  type Policy-map-name;
                                                  description
                                                    "name";
                                                }

                                                leaf type {
                                                  type Policy-map-type-en;
                                                  description
                                                    "type";
                                                }
                                              }  // list policy-map-name-type
                                            }  // container data-hd
                                          }  // container hd-info

                                          leaf enc {
                                            type Policy-obj-enc-en;
                                            description
                                              "enc";
                                          }
                                        }  // list action-policy-info-st
                                      }  // container child-policy

                                      container cac {
                                        when
                                          "../type = 'policy-action-cac'" {
                                          description
                                            "../type = 'POLICY_ACTION_CAC'";
                                        }
                                        description
                                          "cac";
                                        list action-cac-info-st {
                                          description
                                            "action cac info st";
                                          container flow-rate {
                                            description
                                              "flow rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container flow-rate

                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

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

                                          leaf idle-timeout {
                                            type uint16;
                                            description
                                              "idle timeout";
                                          }
                                        }  // list action-cac-info-st
                                      }  // container cac

                                      container pfc {
                                        when
                                          "../type = 'policy-action-pfc'" {
                                          description
                                            "../type = 'POLICY_ACTION_PFC'";
                                        }
                                        description
                                          "pfc";
                                        list action-pfc-info-st {
                                          description
                                            "action pfc info st";
                                          container buffer-size {
                                            description
                                              "buffer size";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container buffer-size

                                          container pause-threshold {
                                            description
                                              "pause threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container pause-threshold

                                          container resume-threshold {
                                            description
                                              "resume threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container resume-threshold

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

                                          leaf buffer-size-flag {
                                            type uint32;
                                            description
                                              "buffer size flag";
                                          }
                                        }  // list action-pfc-info-st
                                      }  // container pfc

                                      container flow-parm {
                                        when
                                          "../type = 'policy-action-afmon-flow-parm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                        }
                                        description
                                          "flow parm";
                                        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";
                                        }
                                      }  // container flow-parm

                                      container ipcbr {
                                        when
                                          "../type = 'policy-action-afmon-ipcbr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                        }
                                        description
                                          "ipcbr";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container ip-bit-rate

                                        container media-bit-rate {
                                          description
                                            "media data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container ipcbr

                                      container rtp {
                                        when
                                          "../type = 'policy-action-afmon-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                        }
                                        description
                                          "rtp";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp

                                      container rtp-mmr {
                                        when
                                          "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                        }
                                        description
                                          "rtp mmr";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp-voice

                                      container mdi {
                                        when
                                          "../type = 'policy-action-afmon-mdi-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                        }
                                        description
                                          "mdi";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi

                                      container mdi-rtp {
                                        when
                                          "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                        }
                                        description
                                          "mdi rtp";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi-rtp

                                      container fmm {
                                        when
                                          "../type = 'policy-action-afmon-fmm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FMM'";
                                        }
                                        description
                                          "fmm";
                                        leaf fmm-name {
                                          type string {
                                            length
                                              "0..33";
                                          }
                                          description
                                            "flow monitor name";
                                        }
                                      }  // container fmm

                                      container pbf {
                                        when
                                          "../type = 'policy-action-pbr-next-hop'" {
                                          description
                                            "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                        }
                                        description
                                          "pbf";
                                        list action-pbf-info-array {
                                          description
                                            "action pbf info array";
                                          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";
                                          }
                                        }  // list action-pbf-info-array
                                      }  // container pbf

                                      container ipv4-nh {
                                        when
                                          "../type = 'policy-action-ipv4-nh'" {
                                          description
                                            "../type = 'POLICY_ACTION_IPV4_NH'";
                                        }
                                        description
                                          "ipv4 nh";
                                        list action-ipv4-nh-info-array {
                                          description
                                            "action ipv4 nh info array";
                                          leaf ipv4-nh-addr {
                                            type inet:ipv4-address;
                                            description
                                              "nh addr";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                        list action-ipv6-nh-info-array {
                                          description
                                            "action ipv6 nh info array";
                                          leaf ipv6-nh-addr {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 Address";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                      }
                                    }  // container actp

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

                                    leaf flags {
                                      type uint16;
                                      description
                                        "flags";
                                    }
                                  }  // list policy-action-info-st
                                }  // container act-infop

                                container nlri-infop {
                                  description
                                    "nlri info pointer";
                                  container nlri {
                                    description
                                      "nlri value";
                                    leaf-list uint8_array {
                                      type uint8;
                                      description
                                        "uint8 array";
                                    }
                                  }  // container nlri
                                }  // 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
                            }  // 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
                        }  // 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
                    }  // list pmaps

                    list pmap-var-list {
                      description
                        "pmap var list";
                      list var-list {
                        description
                          "var list";
                        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";
                        }
                      }  // list var-list
                    }  // list pmap-var-list
                  }  // container 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";
                }

                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";
                }
              }  // 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";
              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";
              }
            }  // 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";
                }

                leaf-list targets {
                  type string;
                  description "targets";
                }

                leaf-list parent-targets {
                  type string;
                  description
                    "parent targets";
                }
              }  // 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";
                  container detail {
                    description "Policy map";
                    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";
                      list policy-map-bg {
                        description
                          "policy map bg";
                        container pmap-var-list {
                          description
                            "contains variable argument data";
                          list pmap-var-list-arr {
                            description
                              "pmap var list arr";
                            container val {
                              description
                                "val";
                              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";
                              }
                            }  // container val

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

                            leaf id {
                              type uint32;
                              description
                                "id";
                            }
                          }  // list pmap-var-list-arr
                        }  // container pmap-var-list

                        container event-infop {
                          description
                            "event infop";
                          list policy-event-info-bg {
                            description
                              "policy event info bg";
                            container class-infop {
                              description
                                "class infop";
                              list policy-class-info-bg {
                                description
                                  "policy class info bg";
                                container clmp-p {
                                  description
                                    "clmp p";
                                  list class-map-bg {
                                    description
                                      "class map bg";
                                    container match-infop {
                                      description
                                        "Pointer to the first Match info";
                                      list class-match-info-st {
                                        description
                                          "class match info st";
                                        container match-data {
                                          description
                                            "Match criteria";
                                          container ipv4-dscp {
                                            when
                                              "../type = 'match-type-ipv4-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                            }
                                            description
                                              "IPv4 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv4-dscp

                                          container ipv6-dscp {
                                            when
                                              "../type = 'match-type-ipv6-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                            }
                                            description
                                              "IPv6 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv6-dscp

                                          container dscp {
                                            when
                                              "../type = 'match-type-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DSCP'";
                                            }
                                            description
                                              "Match DSCP range array";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container dscp

                                          container ipv4-prec {
                                            when
                                              "../type = 'match-type-ipv4-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_PREC'";
                                            }
                                            description
                                              "IPv4 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv4-prec

                                          container ipv6-prec {
                                            when
                                              "../type = 'match-type-ipv6-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_PREC'";
                                            }
                                            description
                                              "IPv6 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv6-prec

                                          container prec {
                                            when
                                              "../type = 'match-type-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_PREC'";
                                            }
                                            description
                                              "Match Precedence array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container prec

                                          container discard-class {
                                            when
                                              "../type = 'match-type-disc-cls'" {
                                              description
                                                "../type = 'MATCH_TYPE_DISC_CLS'";
                                            }
                                            description
                                              "Match Discard Class array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container traffic-class

                                          container proto {
                                            when
                                              "../type = 'match-type-proto'" {
                                              description
                                                "../type = 'MATCH_TYPE_PROTO'";
                                            }
                                            description
                                              "Match Protocol array";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf value {
                                              type uint16;
                                              description
                                                "Value of TCP flag";
                                            }

                                            leaf match-any {
                                              type boolean;
                                              description
                                                "Match any TCP flag bit";
                                            }
                                          }  // container tcp-flag

                                          container icmpv4-type {
                                            when
                                              "../type = 'match-type-icmpv4-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                            }
                                            description
                                              "Match ipv4 icmp type";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list uint32_rng_array {
                                              description
                                                "uint32 rng array";
                                              leaf min {
                                                type uint32;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint32;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint32_rng_array
                                          }  // container mpls-top-label

                                          container cos {
                                            when
                                              "../type = 'match-type-cos'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS'";
                                            }
                                            description
                                              "Match CoS array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos

                                          container cos-inr {
                                            when
                                              "../type = 'match-type-cos-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS_INNER'";
                                            }
                                            description
                                              "Match inner header CoS";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos-inr

                                          container dei {
                                            when
                                              "../type = 'match-type-dei'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI'";
                                            }
                                            description
                                              "Match DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei

                                          container dei-inr {
                                            when
                                              "../type = 'match-type-dei-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI_INNER'";
                                            }
                                            description
                                              "Match inner DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei-inr

                                          container vlan {
                                            when
                                              "../type = 'match-type-vlan'" {
                                              description
                                                "../type = 'MATCH_TYPE_VLAN'";
                                            }
                                            description
                                              "Match VLAN array";
                                            list vlan-id-array {
                                              description
                                                "vlan id array";
                                              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";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            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
                                          }  // container src-mac

                                          container dst-mac {
                                            when
                                              "../type = 'match-type-dst-mac'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_MAC'";
                                            }
                                            description
                                              "Match Destination MAC address";
                                            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
                                          }  // container dst-mac

                                          container atm-clp {
                                            when
                                              "../type = 'match-type-atm-clp'" {
                                              description
                                                "../type = 'MATCH_TYPE_ATM_CLP'";
                                            }
                                            description
                                              "Match ATM CLP level";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container fr-de

                                          container ipv4-acl {
                                            when
                                              "../type = 'match-type-ipv4-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_ACL'";
                                            }
                                            description
                                              "IPv4 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ipv4-acl

                                          container ipv6-acl {
                                            when
                                              "../type = 'match-type-ipv6-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_ACL'";
                                            }
                                            description
                                              "IPv6 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ether-service-acl

                                          container avail-id {
                                            when
                                              "../type = 'match-type-avail-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_AVAIL_ID'";
                                            }
                                            description
                                              "Available Identifiers";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container avail-id

                                          container media-type {
                                            when
                                              "../type = 'match-type-media'" {
                                              description
                                                "../type = 'MATCH_TYPE_MEDIA'";
                                            }
                                            description
                                              "Media Type";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container media-type

                                          container subs-protocol {
                                            when
                                              "../type = 'match-type-subs-protocol'" {
                                              description
                                                "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                            }
                                            description
                                              "Protocol";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container subs-protocol

                                          container dnis {
                                            when
                                              "../type = 'match-type-dnis'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS'";
                                            }
                                            description
                                              "DNIS";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis

                                          container dnis-regex {
                                            when
                                              "../type = 'match-type-dnis-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                            }
                                            description
                                              "DNIS Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis-regex

                                          container domain {
                                            when
                                              "../type = 'match-type-domain'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN'";
                                            }
                                            description
                                              "Domain Name";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain

                                          container domain-regex {
                                            when
                                              "../type = 'match-type-domain-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                            }
                                            description
                                              "Domain Regular Expression";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain-regex

                                          container nas-port {
                                            when
                                              "../type = 'match-type-nas-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_NAS_PORT'";
                                            }
                                            description
                                              "NAS Port";
                                            list nas-port-array {
                                              description
                                                "nas port array";
                                              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";
                                              }
                                            }  // list nas-port-array
                                          }  // container nas-port

                                          container service-name {
                                            when
                                              "../type = 'match-type-service-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                            }
                                            description
                                              "Service Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list mac-addr-array {
                                              description
                                                "mac addr array";
                                              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
                                            }  // list mac-addr-array
                                          }  // container src-addr-mac

                                          container timer {
                                            when
                                              "../type = 'match-type-timer'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER'";
                                            }
                                            description
                                              "Timer";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer

                                          container timer-regexp {
                                            when
                                              "../type = 'match-type-timer-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                            }
                                            description
                                              "Timer Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer-regexp

                                          container tunnel-name {
                                            when
                                              "../type = 'match-type-tunnel-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                            }
                                            description
                                              "Tunnel Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container tunnel-name-regex

                                          container user-name {
                                            when
                                              "../type = 'match-type-user-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_USERNAME'";
                                            }
                                            description
                                              "User Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container unauth-domain-regex

                                          container vendor-id {
                                            when
                                              "../type = 'match-type-vendor-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_VENDOR_ID'";
                                            }
                                            description
                                              "Vendor ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container vendor-id-regex

                                          container access-interface {
                                            when
                                              "../type = 'match-type-access-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                            }
                                            description
                                              "Access interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container access-interface

                                          container input-interface {
                                            when
                                              "../type = 'match-type-input-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                            }
                                            description
                                              "Input interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container input-interface

                                          container ethertype {
                                            when
                                              "../type = 'match-type-ether-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ETHERTYPE'";
                                            }
                                            description
                                              "Ethernet type";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            container flow-keys {
                                              description
                                                "flow keys";
                                              leaf keys {
                                                type yang:hex-string;
                                                description
                                                  "keys";
                                              }

                                              leaf num {
                                                type uint8;
                                                description
                                                  "num";
                                              }
                                            }  // 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)";
                                            }
                                          }  // 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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container circuit-id-regex

                                          container remote-id {
                                            when
                                              "../type = 'match-type-remote-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_REMOTE_ID'";
                                            }
                                            description
                                              "Remote ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container remote-id-regex

                                          container src-port {
                                            when
                                              "../type = 'match-type-src-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_SRC_PORT'";
                                            }
                                            description
                                              "Source port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint16_rng_array
                                          }  // container src-port

                                          container dst-port {
                                            when
                                              "../type = 'match-type-dst-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_PORT'";
                                            }
                                            description
                                              "Destination port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                          }
                                        }  // container match-data

                                        leaf flags {
                                          type uint32;
                                          description
                                            "Flags";
                                        }
                                      }  // list 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
                                }  // container clmp-p

                                container act-infop {
                                  description
                                    "act infop";
                                  list policy-action-info-st {
                                    description
                                      "policy action info st";
                                    container actp {
                                      description
                                        "actp";
                                      container mark {
                                        when
                                          "../type = 'policy-action-mark'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK'";
                                        }
                                        description
                                          "mark";
                                        list action-mark-info {
                                          description
                                            "action mark info";
                                          leaf type {
                                            type Mark-type-en;
                                            description
                                              "type";
                                          }

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

                                          leaf value {
                                            type uint16;
                                            description
                                              "value";
                                          }
                                        }  // list action-mark-info
                                      }  // container mark

                                      container mark2 {
                                        when
                                          "../type = 'policy-action-mark2'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK2'";
                                        }
                                        description
                                          "mark2";
                                        list action-mark2-info {
                                          description
                                            "action mark2 info";
                                          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";
                                          }
                                        }  // list action-mark2-info
                                      }  // container mark2

                                      container wred {
                                        when
                                          "../type = 'policy-action-wred'" {
                                          description
                                            "../type = 'POLICY_ACTION_WRED'";
                                        }
                                        description
                                          "wred";
                                        list action-wred-info {
                                          description
                                            "action wred info";
                                          container match-ranges {
                                            description
                                              "match ranges";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-ranges

                                          container min-threshold {
                                            description
                                              "min threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container min-threshold

                                          container max-threshold {
                                            description
                                              "max threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // 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";
                                          }
                                        }  // list action-wred-info
                                      }  // container wred

                                      container encap {
                                        when
                                          "../type = 'policy-action-encap-seq'" {
                                          description
                                            "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                        }
                                        description
                                          "encap";
                                        leaf seq {
                                          type uint8;
                                          description
                                            "seq";
                                        }
                                      }  // container encap

                                      container prio {
                                        when
                                          "../type = 'policy-action-priority'" {
                                          description
                                            "../type = 'POLICY_ACTION_PRIORITY'";
                                        }
                                        description
                                          "prio";
                                        leaf prio-lvl {
                                          type uint32;
                                          description
                                            "prio lvl";
                                        }
                                      }  // container prio

                                      container bwrem {
                                        when
                                          "../type = 'policy-action-bw-remaining'" {
                                          description
                                            "../type = 'POLICY_ACTION_BW_REMAINING'";
                                        }
                                        description
                                          "bwrem";
                                        container bwrem {
                                          description
                                            "bwrem";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bwrem
                                      }  // container bwrem

                                      container min-bw {
                                        when
                                          "../type = 'policy-action-min-bw'" {
                                          description
                                            "../type = 'POLICY_ACTION_MIN_BW'";
                                        }
                                        description
                                          "min bw";
                                        container bw {
                                          description
                                            "bw";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bw
                                      }  // container min-bw

                                      container authen-aaa {
                                        when
                                          "../type = 'policy-action-authenticate-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                        }
                                        description
                                          "authen aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf authen-password {
                                          type string;
                                          description
                                            "authen password";
                                        }
                                      }  // container authen-aaa

                                      container collect-id {
                                        when
                                          "../type = 'policy-action-collect-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_COLLECT_ID'";
                                        }
                                        description
                                          "collect id";
                                        leaf id {
                                          type Identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container collect-id

                                      container decode-id {
                                        when
                                          "../type = 'policy-action-decode-identifier'" {
                                          description
                                            "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                        }
                                        description
                                          "decode id";
                                        leaf id {
                                          type Decode-identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf format-name {
                                          type string;
                                          description
                                            "format name";
                                        }
                                      }  // container decode-id

                                      container set-timer {
                                        when
                                          "../type = 'policy-action-set-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_SET_TIMER'";
                                        }
                                        description
                                          "set timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }

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

                                        leaf absolute-time {
                                          type string;
                                          description
                                            "absolute time";
                                        }
                                      }  // container set-timer

                                      container stop-timer {
                                        when
                                          "../type = 'policy-action-stop-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_STOP_TIMER'";
                                        }
                                        description
                                          "stop timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }
                                      }  // 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";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container acct-aaa-list

                                      container query-ancp {
                                        when
                                          "../type = 'policy-action-query-ancp'" {
                                          description
                                            "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                        }
                                        description
                                          "query ancp";
                                        leaf enable {
                                          type boolean;
                                          description
                                            "enable";
                                        }
                                      }  // container query-ancp

                                      container prepaid-cfg {
                                        when
                                          "../type = 'policy-action-prepaid-config'" {
                                          description
                                            "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                        }
                                        description
                                          "prepaid cfg";
                                        leaf prepaid-config-profile-name {
                                          type string;
                                          description
                                            "prepaid config profile name";
                                        }
                                      }  // container prepaid-cfg

                                      container timeout-idle {
                                        when
                                          "../type = 'policy-action-timeout-idle'" {
                                          description
                                            "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                        }
                                        description
                                          "timeout idle";
                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container timeout-idle

                                      container proxy-aaa {
                                        when
                                          "../type = 'policy-action-proxy-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_PROXY_AAA'";
                                        }
                                        description
                                          "proxy aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container proxy-aaa

                                      container act-template {
                                        when
                                          "../type = 'policy-action-template-activate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                        }
                                        description
                                          "act template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container act-template

                                      container deact-template {
                                        when
                                          "../type = 'policy-action-template-deactivate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                        }
                                        description
                                          "deact template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container deact-template

                                      container qlimit {
                                        when
                                          "../type = 'policy-action-q-limit'" {
                                          description
                                            "../type = 'POLICY_ACTION_Q_LIMIT'";
                                        }
                                        description
                                          "qlimit";
                                        list action-qlimit-info-array {
                                          description
                                            "action qlimit info array";
                                          container qlim {
                                            description
                                              "qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container qlim

                                          container atmclp-qlim {
                                            description
                                              "atmclp qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container atmclp-qlim

                                          container match-values {
                                            description
                                              "match values";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-values

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

                                          leaf qlimit-flags {
                                            type uint32;
                                            description
                                              "qlimit flags";
                                          }
                                        }  // list 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";
                                        leaf action {
                                          type Acct-en;
                                          description
                                            "action";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container accounting-event-aaa

                                      container authorize-id {
                                        when
                                          "../type = 'policy-action-authorize-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                        }
                                        description
                                          "authorize id";
                                        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";
                                        }
                                      }  // container authorize-id

                                      container afm-react {
                                        when
                                          "../type = 'policy-action-afmon-react'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_REACT'";
                                        }
                                        description
                                          "afm react";
                                        list action-afmon-react-info {
                                          description
                                            "action afmon react info";
                                          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";
                                          }
                                        }  // list action-afmon-react-info
                                      }  // container afm-react

                                      container httpr {
                                        when
                                          "../type = 'policy-action-httpr'" {
                                          description
                                            "../type = 'POLICY_ACTION_HTTPR'";
                                        }
                                        description
                                          "httpr";
                                        leaf redirect-url {
                                          type string;
                                          description
                                            "redirect url";
                                        }
                                      }  // container httpr

                                      container punt {
                                        when
                                          "../type = 'policy-action-punt'" {
                                          description
                                            "../type = 'POLICY_ACTION_PUNT'";
                                        }
                                        description
                                          "punt";
                                        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";
                                        }
                                      }  // container punt

                                      container copy {
                                        when
                                          "../type = 'policy-action-copy'" {
                                          description
                                            "../type = 'POLICY_ACTION_COPY'";
                                        }
                                        description
                                          "copy";
                                        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";
                                        }
                                      }  // container copy

                                      container sfrag {
                                        when
                                          "../type = 'policy-action-sfrag'" {
                                          description
                                            "../type = 'POLICY_ACTION_SFRAG'";
                                        }
                                        description
                                          "sfrag";
                                        leaf name {
                                          type string;
                                          description
                                            "Service Fragment Name";
                                        }
                                      }  // container sfrag

                                      container redirect {
                                        when
                                          "../type = 'policy-action-redirect'" {
                                          description
                                            "../type = 'POLICY_ACTION_REDIRECT'";
                                        }
                                        description
                                          "redirect";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf type {
                                          type Redirect-type-e;
                                          description
                                            "type";
                                        }
                                      }  // container redirect

                                      container out-intf {
                                        when
                                          "../type = 'policy-action-output-interface'" {
                                          description
                                            "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                        }
                                        description
                                          "out intf";
                                        leaf out-ifname {
                                          type string;
                                          description
                                            "output interface name";
                                        }
                                      }  // container out-intf

                                      container serv-func {
                                        when
                                          "../type = 'policy-action-service-function-path'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                        }
                                        description
                                          "serv func";
                                        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";
                                        }
                                      }  // 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";
                                        list action-police-info-st {
                                          description
                                            "action police info array";
                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

                                          container burst {
                                            description
                                              "burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container burst

                                          container peak-rate {
                                            description
                                              "peak rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-rate

                                          container peak-burst {
                                            description
                                              "peak burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-burst

                                          container cdvt {
                                            description
                                              "cdvt";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container cdvt

                                          container conform-actns {
                                            description
                                              "conform actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container conform-actns

                                          container exceed-actns {
                                            description
                                              "exceed actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container exceed-actns

                                          container violate-actns {
                                            description
                                              "violate actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container violate-actns

                                          container confclass-p {
                                            description
                                              "confclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // container confclass-p

                                          container excdclass-p {
                                            description
                                              "excdclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // 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";
                                          }
                                        }  // list action-police-info-st
                                      }  // container police

                                      container shape {
                                        when
                                          "../type = 'policy-action-shape'" {
                                          description
                                            "../type = 'POLICY_ACTION_SHAPE'";
                                        }
                                        description
                                          "shape";
                                        list action-shape-info-st {
                                          description
                                            "action police info array";
                                          container bw {
                                            description
                                              "bw";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container bw

                                          container be {
                                            description
                                              "be";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container be
                                        }  // list action-shape-info-st
                                      }  // container shape

                                      container child-policy {
                                        when
                                          "../type = 'policy-action-serv-pol'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERV_POL'";
                                        }
                                        description
                                          "child policy";
                                        list action-policy-info-st {
                                          description
                                            "child policy info";
                                          container info {
                                            when
                                              "../enc = 'policy-obj-enc-name'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_NAME'";
                                            }
                                            description
                                              "info";
                                            leaf name {
                                              type Policy-map-name;
                                              description
                                                "name";
                                            }

                                            leaf type {
                                              type Policy-map-type-en;
                                              description
                                                "type";
                                            }
                                          }  // container info

                                          container hd-info {
                                            when
                                              "../enc = 'policy-obj-enc-hdl'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_HDL'";
                                            }
                                            description
                                              "hd info";
                                            container data-hd {
                                              description
                                                "data hd";
                                              list policy-map-name-type {
                                                description
                                                  "policy map type and name";
                                                leaf name {
                                                  type Policy-map-name;
                                                  description
                                                    "name";
                                                }

                                                leaf type {
                                                  type Policy-map-type-en;
                                                  description
                                                    "type";
                                                }
                                              }  // list policy-map-name-type
                                            }  // container data-hd
                                          }  // container hd-info

                                          leaf enc {
                                            type Policy-obj-enc-en;
                                            description
                                              "enc";
                                          }
                                        }  // list action-policy-info-st
                                      }  // container child-policy

                                      container cac {
                                        when
                                          "../type = 'policy-action-cac'" {
                                          description
                                            "../type = 'POLICY_ACTION_CAC'";
                                        }
                                        description
                                          "cac";
                                        list action-cac-info-st {
                                          description
                                            "action cac info st";
                                          container flow-rate {
                                            description
                                              "flow rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container flow-rate

                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

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

                                          leaf idle-timeout {
                                            type uint16;
                                            description
                                              "idle timeout";
                                          }
                                        }  // list action-cac-info-st
                                      }  // container cac

                                      container pfc {
                                        when
                                          "../type = 'policy-action-pfc'" {
                                          description
                                            "../type = 'POLICY_ACTION_PFC'";
                                        }
                                        description
                                          "pfc";
                                        list action-pfc-info-st {
                                          description
                                            "action pfc info st";
                                          container buffer-size {
                                            description
                                              "buffer size";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container buffer-size

                                          container pause-threshold {
                                            description
                                              "pause threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container pause-threshold

                                          container resume-threshold {
                                            description
                                              "resume threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container resume-threshold

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

                                          leaf buffer-size-flag {
                                            type uint32;
                                            description
                                              "buffer size flag";
                                          }
                                        }  // list action-pfc-info-st
                                      }  // container pfc

                                      container flow-parm {
                                        when
                                          "../type = 'policy-action-afmon-flow-parm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                        }
                                        description
                                          "flow parm";
                                        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";
                                        }
                                      }  // container flow-parm

                                      container ipcbr {
                                        when
                                          "../type = 'policy-action-afmon-ipcbr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                        }
                                        description
                                          "ipcbr";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container ip-bit-rate

                                        container media-bit-rate {
                                          description
                                            "media data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container ipcbr

                                      container rtp {
                                        when
                                          "../type = 'policy-action-afmon-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                        }
                                        description
                                          "rtp";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp

                                      container rtp-mmr {
                                        when
                                          "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                        }
                                        description
                                          "rtp mmr";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp-voice

                                      container mdi {
                                        when
                                          "../type = 'policy-action-afmon-mdi-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                        }
                                        description
                                          "mdi";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi

                                      container mdi-rtp {
                                        when
                                          "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                        }
                                        description
                                          "mdi rtp";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi-rtp

                                      container fmm {
                                        when
                                          "../type = 'policy-action-afmon-fmm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FMM'";
                                        }
                                        description
                                          "fmm";
                                        leaf fmm-name {
                                          type string {
                                            length
                                              "0..33";
                                          }
                                          description
                                            "flow monitor name";
                                        }
                                      }  // container fmm

                                      container pbf {
                                        when
                                          "../type = 'policy-action-pbr-next-hop'" {
                                          description
                                            "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                        }
                                        description
                                          "pbf";
                                        list action-pbf-info-array {
                                          description
                                            "action pbf info array";
                                          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";
                                          }
                                        }  // list action-pbf-info-array
                                      }  // container pbf

                                      container ipv4-nh {
                                        when
                                          "../type = 'policy-action-ipv4-nh'" {
                                          description
                                            "../type = 'POLICY_ACTION_IPV4_NH'";
                                        }
                                        description
                                          "ipv4 nh";
                                        list action-ipv4-nh-info-array {
                                          description
                                            "action ipv4 nh info array";
                                          leaf ipv4-nh-addr {
                                            type inet:ipv4-address;
                                            description
                                              "nh addr";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                        list action-ipv6-nh-info-array {
                                          description
                                            "action ipv6 nh info array";
                                          leaf ipv6-nh-addr {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 Address";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                      }
                                    }  // container actp

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

                                    leaf flags {
                                      type uint16;
                                      description
                                        "flags";
                                    }
                                  }  // list policy-action-info-st
                                }  // container act-infop

                                container nlri-infop {
                                  description
                                    "nlri info pointer";
                                  container nlri {
                                    description
                                      "nlri value";
                                    leaf-list uint8_array {
                                      type uint8;
                                      description
                                        "uint8 array";
                                    }
                                  }  // container nlri
                                }  // 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
                            }  // 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
                        }  // 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
                    }  // list pmaps

                    list pmap-var-list {
                      description
                        "pmap var list";
                      list var-list {
                        description
                          "var list";
                        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";
                        }
                      }  // list var-list
                    }  // list pmap-var-list
                  }  // container detail
                }  // container transient-output

                container transient-input {
                  description
                    "Input direction table";
                  container detail {
                    description "Policy map";
                    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";
                      list policy-map-bg {
                        description
                          "policy map bg";
                        container pmap-var-list {
                          description
                            "contains variable argument data";
                          list pmap-var-list-arr {
                            description
                              "pmap var list arr";
                            container val {
                              description
                                "val";
                              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";
                              }
                            }  // container val

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

                            leaf id {
                              type uint32;
                              description
                                "id";
                            }
                          }  // list pmap-var-list-arr
                        }  // container pmap-var-list

                        container event-infop {
                          description
                            "event infop";
                          list policy-event-info-bg {
                            description
                              "policy event info bg";
                            container class-infop {
                              description
                                "class infop";
                              list policy-class-info-bg {
                                description
                                  "policy class info bg";
                                container clmp-p {
                                  description
                                    "clmp p";
                                  list class-map-bg {
                                    description
                                      "class map bg";
                                    container match-infop {
                                      description
                                        "Pointer to the first Match info";
                                      list class-match-info-st {
                                        description
                                          "class match info st";
                                        container match-data {
                                          description
                                            "Match criteria";
                                          container ipv4-dscp {
                                            when
                                              "../type = 'match-type-ipv4-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                            }
                                            description
                                              "IPv4 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv4-dscp

                                          container ipv6-dscp {
                                            when
                                              "../type = 'match-type-ipv6-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                            }
                                            description
                                              "IPv6 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv6-dscp

                                          container dscp {
                                            when
                                              "../type = 'match-type-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DSCP'";
                                            }
                                            description
                                              "Match DSCP range array";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container dscp

                                          container ipv4-prec {
                                            when
                                              "../type = 'match-type-ipv4-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_PREC'";
                                            }
                                            description
                                              "IPv4 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv4-prec

                                          container ipv6-prec {
                                            when
                                              "../type = 'match-type-ipv6-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_PREC'";
                                            }
                                            description
                                              "IPv6 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv6-prec

                                          container prec {
                                            when
                                              "../type = 'match-type-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_PREC'";
                                            }
                                            description
                                              "Match Precedence array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container prec

                                          container discard-class {
                                            when
                                              "../type = 'match-type-disc-cls'" {
                                              description
                                                "../type = 'MATCH_TYPE_DISC_CLS'";
                                            }
                                            description
                                              "Match Discard Class array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container traffic-class

                                          container proto {
                                            when
                                              "../type = 'match-type-proto'" {
                                              description
                                                "../type = 'MATCH_TYPE_PROTO'";
                                            }
                                            description
                                              "Match Protocol array";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf value {
                                              type uint16;
                                              description
                                                "Value of TCP flag";
                                            }

                                            leaf match-any {
                                              type boolean;
                                              description
                                                "Match any TCP flag bit";
                                            }
                                          }  // container tcp-flag

                                          container icmpv4-type {
                                            when
                                              "../type = 'match-type-icmpv4-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                            }
                                            description
                                              "Match ipv4 icmp type";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list uint32_rng_array {
                                              description
                                                "uint32 rng array";
                                              leaf min {
                                                type uint32;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint32;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint32_rng_array
                                          }  // container mpls-top-label

                                          container cos {
                                            when
                                              "../type = 'match-type-cos'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS'";
                                            }
                                            description
                                              "Match CoS array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos

                                          container cos-inr {
                                            when
                                              "../type = 'match-type-cos-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS_INNER'";
                                            }
                                            description
                                              "Match inner header CoS";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos-inr

                                          container dei {
                                            when
                                              "../type = 'match-type-dei'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI'";
                                            }
                                            description
                                              "Match DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei

                                          container dei-inr {
                                            when
                                              "../type = 'match-type-dei-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI_INNER'";
                                            }
                                            description
                                              "Match inner DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei-inr

                                          container vlan {
                                            when
                                              "../type = 'match-type-vlan'" {
                                              description
                                                "../type = 'MATCH_TYPE_VLAN'";
                                            }
                                            description
                                              "Match VLAN array";
                                            list vlan-id-array {
                                              description
                                                "vlan id array";
                                              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";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            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
                                          }  // container src-mac

                                          container dst-mac {
                                            when
                                              "../type = 'match-type-dst-mac'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_MAC'";
                                            }
                                            description
                                              "Match Destination MAC address";
                                            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
                                          }  // container dst-mac

                                          container atm-clp {
                                            when
                                              "../type = 'match-type-atm-clp'" {
                                              description
                                                "../type = 'MATCH_TYPE_ATM_CLP'";
                                            }
                                            description
                                              "Match ATM CLP level";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container fr-de

                                          container ipv4-acl {
                                            when
                                              "../type = 'match-type-ipv4-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_ACL'";
                                            }
                                            description
                                              "IPv4 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ipv4-acl

                                          container ipv6-acl {
                                            when
                                              "../type = 'match-type-ipv6-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_ACL'";
                                            }
                                            description
                                              "IPv6 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ether-service-acl

                                          container avail-id {
                                            when
                                              "../type = 'match-type-avail-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_AVAIL_ID'";
                                            }
                                            description
                                              "Available Identifiers";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container avail-id

                                          container media-type {
                                            when
                                              "../type = 'match-type-media'" {
                                              description
                                                "../type = 'MATCH_TYPE_MEDIA'";
                                            }
                                            description
                                              "Media Type";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container media-type

                                          container subs-protocol {
                                            when
                                              "../type = 'match-type-subs-protocol'" {
                                              description
                                                "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                            }
                                            description
                                              "Protocol";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container subs-protocol

                                          container dnis {
                                            when
                                              "../type = 'match-type-dnis'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS'";
                                            }
                                            description
                                              "DNIS";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis

                                          container dnis-regex {
                                            when
                                              "../type = 'match-type-dnis-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                            }
                                            description
                                              "DNIS Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis-regex

                                          container domain {
                                            when
                                              "../type = 'match-type-domain'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN'";
                                            }
                                            description
                                              "Domain Name";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain

                                          container domain-regex {
                                            when
                                              "../type = 'match-type-domain-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                            }
                                            description
                                              "Domain Regular Expression";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain-regex

                                          container nas-port {
                                            when
                                              "../type = 'match-type-nas-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_NAS_PORT'";
                                            }
                                            description
                                              "NAS Port";
                                            list nas-port-array {
                                              description
                                                "nas port array";
                                              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";
                                              }
                                            }  // list nas-port-array
                                          }  // container nas-port

                                          container service-name {
                                            when
                                              "../type = 'match-type-service-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                            }
                                            description
                                              "Service Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list mac-addr-array {
                                              description
                                                "mac addr array";
                                              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
                                            }  // list mac-addr-array
                                          }  // container src-addr-mac

                                          container timer {
                                            when
                                              "../type = 'match-type-timer'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER'";
                                            }
                                            description
                                              "Timer";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer

                                          container timer-regexp {
                                            when
                                              "../type = 'match-type-timer-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                            }
                                            description
                                              "Timer Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer-regexp

                                          container tunnel-name {
                                            when
                                              "../type = 'match-type-tunnel-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                            }
                                            description
                                              "Tunnel Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container tunnel-name-regex

                                          container user-name {
                                            when
                                              "../type = 'match-type-user-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_USERNAME'";
                                            }
                                            description
                                              "User Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container unauth-domain-regex

                                          container vendor-id {
                                            when
                                              "../type = 'match-type-vendor-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_VENDOR_ID'";
                                            }
                                            description
                                              "Vendor ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container vendor-id-regex

                                          container access-interface {
                                            when
                                              "../type = 'match-type-access-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                            }
                                            description
                                              "Access interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container access-interface

                                          container input-interface {
                                            when
                                              "../type = 'match-type-input-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                            }
                                            description
                                              "Input interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container input-interface

                                          container ethertype {
                                            when
                                              "../type = 'match-type-ether-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ETHERTYPE'";
                                            }
                                            description
                                              "Ethernet type";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            container flow-keys {
                                              description
                                                "flow keys";
                                              leaf keys {
                                                type yang:hex-string;
                                                description
                                                  "keys";
                                              }

                                              leaf num {
                                                type uint8;
                                                description
                                                  "num";
                                              }
                                            }  // 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)";
                                            }
                                          }  // 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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container circuit-id-regex

                                          container remote-id {
                                            when
                                              "../type = 'match-type-remote-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_REMOTE_ID'";
                                            }
                                            description
                                              "Remote ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container remote-id-regex

                                          container src-port {
                                            when
                                              "../type = 'match-type-src-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_SRC_PORT'";
                                            }
                                            description
                                              "Source port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint16_rng_array
                                          }  // container src-port

                                          container dst-port {
                                            when
                                              "../type = 'match-type-dst-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_PORT'";
                                            }
                                            description
                                              "Destination port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                          }
                                        }  // container match-data

                                        leaf flags {
                                          type uint32;
                                          description
                                            "Flags";
                                        }
                                      }  // list 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
                                }  // container clmp-p

                                container act-infop {
                                  description
                                    "act infop";
                                  list policy-action-info-st {
                                    description
                                      "policy action info st";
                                    container actp {
                                      description
                                        "actp";
                                      container mark {
                                        when
                                          "../type = 'policy-action-mark'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK'";
                                        }
                                        description
                                          "mark";
                                        list action-mark-info {
                                          description
                                            "action mark info";
                                          leaf type {
                                            type Mark-type-en;
                                            description
                                              "type";
                                          }

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

                                          leaf value {
                                            type uint16;
                                            description
                                              "value";
                                          }
                                        }  // list action-mark-info
                                      }  // container mark

                                      container mark2 {
                                        when
                                          "../type = 'policy-action-mark2'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK2'";
                                        }
                                        description
                                          "mark2";
                                        list action-mark2-info {
                                          description
                                            "action mark2 info";
                                          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";
                                          }
                                        }  // list action-mark2-info
                                      }  // container mark2

                                      container wred {
                                        when
                                          "../type = 'policy-action-wred'" {
                                          description
                                            "../type = 'POLICY_ACTION_WRED'";
                                        }
                                        description
                                          "wred";
                                        list action-wred-info {
                                          description
                                            "action wred info";
                                          container match-ranges {
                                            description
                                              "match ranges";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-ranges

                                          container min-threshold {
                                            description
                                              "min threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container min-threshold

                                          container max-threshold {
                                            description
                                              "max threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // 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";
                                          }
                                        }  // list action-wred-info
                                      }  // container wred

                                      container encap {
                                        when
                                          "../type = 'policy-action-encap-seq'" {
                                          description
                                            "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                        }
                                        description
                                          "encap";
                                        leaf seq {
                                          type uint8;
                                          description
                                            "seq";
                                        }
                                      }  // container encap

                                      container prio {
                                        when
                                          "../type = 'policy-action-priority'" {
                                          description
                                            "../type = 'POLICY_ACTION_PRIORITY'";
                                        }
                                        description
                                          "prio";
                                        leaf prio-lvl {
                                          type uint32;
                                          description
                                            "prio lvl";
                                        }
                                      }  // container prio

                                      container bwrem {
                                        when
                                          "../type = 'policy-action-bw-remaining'" {
                                          description
                                            "../type = 'POLICY_ACTION_BW_REMAINING'";
                                        }
                                        description
                                          "bwrem";
                                        container bwrem {
                                          description
                                            "bwrem";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bwrem
                                      }  // container bwrem

                                      container min-bw {
                                        when
                                          "../type = 'policy-action-min-bw'" {
                                          description
                                            "../type = 'POLICY_ACTION_MIN_BW'";
                                        }
                                        description
                                          "min bw";
                                        container bw {
                                          description
                                            "bw";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bw
                                      }  // container min-bw

                                      container authen-aaa {
                                        when
                                          "../type = 'policy-action-authenticate-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                        }
                                        description
                                          "authen aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf authen-password {
                                          type string;
                                          description
                                            "authen password";
                                        }
                                      }  // container authen-aaa

                                      container collect-id {
                                        when
                                          "../type = 'policy-action-collect-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_COLLECT_ID'";
                                        }
                                        description
                                          "collect id";
                                        leaf id {
                                          type Identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container collect-id

                                      container decode-id {
                                        when
                                          "../type = 'policy-action-decode-identifier'" {
                                          description
                                            "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                        }
                                        description
                                          "decode id";
                                        leaf id {
                                          type Decode-identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf format-name {
                                          type string;
                                          description
                                            "format name";
                                        }
                                      }  // container decode-id

                                      container set-timer {
                                        when
                                          "../type = 'policy-action-set-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_SET_TIMER'";
                                        }
                                        description
                                          "set timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }

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

                                        leaf absolute-time {
                                          type string;
                                          description
                                            "absolute time";
                                        }
                                      }  // container set-timer

                                      container stop-timer {
                                        when
                                          "../type = 'policy-action-stop-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_STOP_TIMER'";
                                        }
                                        description
                                          "stop timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }
                                      }  // 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";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container acct-aaa-list

                                      container query-ancp {
                                        when
                                          "../type = 'policy-action-query-ancp'" {
                                          description
                                            "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                        }
                                        description
                                          "query ancp";
                                        leaf enable {
                                          type boolean;
                                          description
                                            "enable";
                                        }
                                      }  // container query-ancp

                                      container prepaid-cfg {
                                        when
                                          "../type = 'policy-action-prepaid-config'" {
                                          description
                                            "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                        }
                                        description
                                          "prepaid cfg";
                                        leaf prepaid-config-profile-name {
                                          type string;
                                          description
                                            "prepaid config profile name";
                                        }
                                      }  // container prepaid-cfg

                                      container timeout-idle {
                                        when
                                          "../type = 'policy-action-timeout-idle'" {
                                          description
                                            "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                        }
                                        description
                                          "timeout idle";
                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container timeout-idle

                                      container proxy-aaa {
                                        when
                                          "../type = 'policy-action-proxy-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_PROXY_AAA'";
                                        }
                                        description
                                          "proxy aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container proxy-aaa

                                      container act-template {
                                        when
                                          "../type = 'policy-action-template-activate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                        }
                                        description
                                          "act template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container act-template

                                      container deact-template {
                                        when
                                          "../type = 'policy-action-template-deactivate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                        }
                                        description
                                          "deact template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container deact-template

                                      container qlimit {
                                        when
                                          "../type = 'policy-action-q-limit'" {
                                          description
                                            "../type = 'POLICY_ACTION_Q_LIMIT'";
                                        }
                                        description
                                          "qlimit";
                                        list action-qlimit-info-array {
                                          description
                                            "action qlimit info array";
                                          container qlim {
                                            description
                                              "qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container qlim

                                          container atmclp-qlim {
                                            description
                                              "atmclp qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container atmclp-qlim

                                          container match-values {
                                            description
                                              "match values";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-values

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

                                          leaf qlimit-flags {
                                            type uint32;
                                            description
                                              "qlimit flags";
                                          }
                                        }  // list 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";
                                        leaf action {
                                          type Acct-en;
                                          description
                                            "action";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container accounting-event-aaa

                                      container authorize-id {
                                        when
                                          "../type = 'policy-action-authorize-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                        }
                                        description
                                          "authorize id";
                                        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";
                                        }
                                      }  // container authorize-id

                                      container afm-react {
                                        when
                                          "../type = 'policy-action-afmon-react'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_REACT'";
                                        }
                                        description
                                          "afm react";
                                        list action-afmon-react-info {
                                          description
                                            "action afmon react info";
                                          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";
                                          }
                                        }  // list action-afmon-react-info
                                      }  // container afm-react

                                      container httpr {
                                        when
                                          "../type = 'policy-action-httpr'" {
                                          description
                                            "../type = 'POLICY_ACTION_HTTPR'";
                                        }
                                        description
                                          "httpr";
                                        leaf redirect-url {
                                          type string;
                                          description
                                            "redirect url";
                                        }
                                      }  // container httpr

                                      container punt {
                                        when
                                          "../type = 'policy-action-punt'" {
                                          description
                                            "../type = 'POLICY_ACTION_PUNT'";
                                        }
                                        description
                                          "punt";
                                        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";
                                        }
                                      }  // container punt

                                      container copy {
                                        when
                                          "../type = 'policy-action-copy'" {
                                          description
                                            "../type = 'POLICY_ACTION_COPY'";
                                        }
                                        description
                                          "copy";
                                        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";
                                        }
                                      }  // container copy

                                      container sfrag {
                                        when
                                          "../type = 'policy-action-sfrag'" {
                                          description
                                            "../type = 'POLICY_ACTION_SFRAG'";
                                        }
                                        description
                                          "sfrag";
                                        leaf name {
                                          type string;
                                          description
                                            "Service Fragment Name";
                                        }
                                      }  // container sfrag

                                      container redirect {
                                        when
                                          "../type = 'policy-action-redirect'" {
                                          description
                                            "../type = 'POLICY_ACTION_REDIRECT'";
                                        }
                                        description
                                          "redirect";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf type {
                                          type Redirect-type-e;
                                          description
                                            "type";
                                        }
                                      }  // container redirect

                                      container out-intf {
                                        when
                                          "../type = 'policy-action-output-interface'" {
                                          description
                                            "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                        }
                                        description
                                          "out intf";
                                        leaf out-ifname {
                                          type string;
                                          description
                                            "output interface name";
                                        }
                                      }  // container out-intf

                                      container serv-func {
                                        when
                                          "../type = 'policy-action-service-function-path'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                        }
                                        description
                                          "serv func";
                                        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";
                                        }
                                      }  // 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";
                                        list action-police-info-st {
                                          description
                                            "action police info array";
                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

                                          container burst {
                                            description
                                              "burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container burst

                                          container peak-rate {
                                            description
                                              "peak rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-rate

                                          container peak-burst {
                                            description
                                              "peak burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-burst

                                          container cdvt {
                                            description
                                              "cdvt";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container cdvt

                                          container conform-actns {
                                            description
                                              "conform actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container conform-actns

                                          container exceed-actns {
                                            description
                                              "exceed actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container exceed-actns

                                          container violate-actns {
                                            description
                                              "violate actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container violate-actns

                                          container confclass-p {
                                            description
                                              "confclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // container confclass-p

                                          container excdclass-p {
                                            description
                                              "excdclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // 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";
                                          }
                                        }  // list action-police-info-st
                                      }  // container police

                                      container shape {
                                        when
                                          "../type = 'policy-action-shape'" {
                                          description
                                            "../type = 'POLICY_ACTION_SHAPE'";
                                        }
                                        description
                                          "shape";
                                        list action-shape-info-st {
                                          description
                                            "action police info array";
                                          container bw {
                                            description
                                              "bw";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container bw

                                          container be {
                                            description
                                              "be";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container be
                                        }  // list action-shape-info-st
                                      }  // container shape

                                      container child-policy {
                                        when
                                          "../type = 'policy-action-serv-pol'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERV_POL'";
                                        }
                                        description
                                          "child policy";
                                        list action-policy-info-st {
                                          description
                                            "child policy info";
                                          container info {
                                            when
                                              "../enc = 'policy-obj-enc-name'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_NAME'";
                                            }
                                            description
                                              "info";
                                            leaf name {
                                              type Policy-map-name;
                                              description
                                                "name";
                                            }

                                            leaf type {
                                              type Policy-map-type-en;
                                              description
                                                "type";
                                            }
                                          }  // container info

                                          container hd-info {
                                            when
                                              "../enc = 'policy-obj-enc-hdl'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_HDL'";
                                            }
                                            description
                                              "hd info";
                                            container data-hd {
                                              description
                                                "data hd";
                                              list policy-map-name-type {
                                                description
                                                  "policy map type and name";
                                                leaf name {
                                                  type Policy-map-name;
                                                  description
                                                    "name";
                                                }

                                                leaf type {
                                                  type Policy-map-type-en;
                                                  description
                                                    "type";
                                                }
                                              }  // list policy-map-name-type
                                            }  // container data-hd
                                          }  // container hd-info

                                          leaf enc {
                                            type Policy-obj-enc-en;
                                            description
                                              "enc";
                                          }
                                        }  // list action-policy-info-st
                                      }  // container child-policy

                                      container cac {
                                        when
                                          "../type = 'policy-action-cac'" {
                                          description
                                            "../type = 'POLICY_ACTION_CAC'";
                                        }
                                        description
                                          "cac";
                                        list action-cac-info-st {
                                          description
                                            "action cac info st";
                                          container flow-rate {
                                            description
                                              "flow rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container flow-rate

                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

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

                                          leaf idle-timeout {
                                            type uint16;
                                            description
                                              "idle timeout";
                                          }
                                        }  // list action-cac-info-st
                                      }  // container cac

                                      container pfc {
                                        when
                                          "../type = 'policy-action-pfc'" {
                                          description
                                            "../type = 'POLICY_ACTION_PFC'";
                                        }
                                        description
                                          "pfc";
                                        list action-pfc-info-st {
                                          description
                                            "action pfc info st";
                                          container buffer-size {
                                            description
                                              "buffer size";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container buffer-size

                                          container pause-threshold {
                                            description
                                              "pause threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container pause-threshold

                                          container resume-threshold {
                                            description
                                              "resume threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container resume-threshold

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

                                          leaf buffer-size-flag {
                                            type uint32;
                                            description
                                              "buffer size flag";
                                          }
                                        }  // list action-pfc-info-st
                                      }  // container pfc

                                      container flow-parm {
                                        when
                                          "../type = 'policy-action-afmon-flow-parm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                        }
                                        description
                                          "flow parm";
                                        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";
                                        }
                                      }  // container flow-parm

                                      container ipcbr {
                                        when
                                          "../type = 'policy-action-afmon-ipcbr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                        }
                                        description
                                          "ipcbr";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container ip-bit-rate

                                        container media-bit-rate {
                                          description
                                            "media data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container ipcbr

                                      container rtp {
                                        when
                                          "../type = 'policy-action-afmon-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                        }
                                        description
                                          "rtp";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp

                                      container rtp-mmr {
                                        when
                                          "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                        }
                                        description
                                          "rtp mmr";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp-voice

                                      container mdi {
                                        when
                                          "../type = 'policy-action-afmon-mdi-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                        }
                                        description
                                          "mdi";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi

                                      container mdi-rtp {
                                        when
                                          "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                        }
                                        description
                                          "mdi rtp";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi-rtp

                                      container fmm {
                                        when
                                          "../type = 'policy-action-afmon-fmm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FMM'";
                                        }
                                        description
                                          "fmm";
                                        leaf fmm-name {
                                          type string {
                                            length
                                              "0..33";
                                          }
                                          description
                                            "flow monitor name";
                                        }
                                      }  // container fmm

                                      container pbf {
                                        when
                                          "../type = 'policy-action-pbr-next-hop'" {
                                          description
                                            "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                        }
                                        description
                                          "pbf";
                                        list action-pbf-info-array {
                                          description
                                            "action pbf info array";
                                          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";
                                          }
                                        }  // list action-pbf-info-array
                                      }  // container pbf

                                      container ipv4-nh {
                                        when
                                          "../type = 'policy-action-ipv4-nh'" {
                                          description
                                            "../type = 'POLICY_ACTION_IPV4_NH'";
                                        }
                                        description
                                          "ipv4 nh";
                                        list action-ipv4-nh-info-array {
                                          description
                                            "action ipv4 nh info array";
                                          leaf ipv4-nh-addr {
                                            type inet:ipv4-address;
                                            description
                                              "nh addr";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                        list action-ipv6-nh-info-array {
                                          description
                                            "action ipv6 nh info array";
                                          leaf ipv6-nh-addr {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 Address";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                      }
                                    }  // container actp

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

                                    leaf flags {
                                      type uint16;
                                      description
                                        "flags";
                                    }
                                  }  // list policy-action-info-st
                                }  // container act-infop

                                container nlri-infop {
                                  description
                                    "nlri info pointer";
                                  container nlri {
                                    description
                                      "nlri value";
                                    leaf-list uint8_array {
                                      type uint8;
                                      description
                                        "uint8 array";
                                    }
                                  }  // container nlri
                                }  // 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
                            }  // 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
                        }  // 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
                    }  // list pmaps

                    list pmap-var-list {
                      description
                        "pmap var list";
                      list var-list {
                        description
                          "var list";
                        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";
                        }
                      }  // list var-list
                    }  // list pmap-var-list
                  }  // container 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

        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";
                }

                leaf-list targets {
                  type string;
                  description "targets";
                }

                leaf-list parent-targets {
                  type string;
                  description
                    "parent targets";
                }
              }  // list policy-map-target
            }  // container policy-map-targets

            container policy-map-target-summary {
              description "Policy-map table";
              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";
              }
            }  // 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";
                }

                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";
                }
              }  // 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

        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";
                  }

                  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";
                    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";
                    }
                  }  // list reference

                  list objects {
                    description
                      "Each object details";
                    leaf object-name {
                      type string {
                        length "0..64";
                      }
                      description
                        "Name of object (Policymap/Classmap)";
                    }
                  }  // list objects

                  list class-map-reference {
                    description
                      "Each Classmapdetails";
                    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";
                      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";
                      }
                    }  // list policy-map-reference
                  }  // list class-map-reference
                }  // 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";
                  }

                  list class-map-bg {
                    description
                      "class map bg";
                    container match-infop {
                      description
                        "Pointer to the first Match info";
                      list class-match-info-st {
                        description
                          "class match info st";
                        container match-data {
                          description
                            "Match criteria";
                          container ipv4-dscp {
                            when
                              "../type = 'match-type-ipv4-dscp'" {
                              description
                                "../type = 'MATCH_TYPE_IPV4_DSCP'";
                            }
                            description
                              "IPv4 DSCP";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list uint8_rng_array
                          }  // container ipv4-dscp

                          container ipv6-dscp {
                            when
                              "../type = 'match-type-ipv6-dscp'" {
                              description
                                "../type = 'MATCH_TYPE_IPV6_DSCP'";
                            }
                            description
                              "IPv6 DSCP";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list uint8_rng_array
                          }  // container ipv6-dscp

                          container dscp {
                            when
                              "../type = 'match-type-dscp'" {
                              description
                                "../type = 'MATCH_TYPE_DSCP'";
                            }
                            description
                              "Match DSCP range array";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list uint8_rng_array
                          }  // container dscp

                          container ipv4-prec {
                            when
                              "../type = 'match-type-ipv4-prec'" {
                              description
                                "../type = 'MATCH_TYPE_IPV4_PREC'";
                            }
                            description
                              "IPv4 Precedence";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container ipv4-prec

                          container ipv6-prec {
                            when
                              "../type = 'match-type-ipv6-prec'" {
                              description
                                "../type = 'MATCH_TYPE_IPV6_PREC'";
                            }
                            description
                              "IPv6 Precedence";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container ipv6-prec

                          container prec {
                            when
                              "../type = 'match-type-prec'" {
                              description
                                "../type = 'MATCH_TYPE_PREC'";
                            }
                            description
                              "Match Precedence array";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container prec

                          container discard-class {
                            when
                              "../type = 'match-type-disc-cls'" {
                              description
                                "../type = 'MATCH_TYPE_DISC_CLS'";
                            }
                            description
                              "Match Discard Class array";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "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";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list uint8_rng_array
                          }  // container traffic-class

                          container proto {
                            when
                              "../type = 'match-type-proto'" {
                              description
                                "../type = 'MATCH_TYPE_PROTO'";
                            }
                            description
                              "Match Protocol array";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            leaf value {
                              type uint16;
                              description
                                "Value of TCP flag";
                            }

                            leaf match-any {
                              type boolean;
                              description
                                "Match any TCP flag bit";
                            }
                          }  // container tcp-flag

                          container icmpv4-type {
                            when
                              "../type = 'match-type-icmpv4-type'" {
                              description
                                "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                            }
                            description
                              "Match ipv4 icmp type";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint8_rng_array {
                              description
                                "uint8 rng array";
                              leaf min {
                                type uint8;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint8;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "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";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            list uint32_rng_array {
                              description
                                "uint32 rng array";
                              leaf min {
                                type uint32;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint32;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list uint32_rng_array
                          }  // container mpls-top-label

                          container cos {
                            when
                              "../type = 'match-type-cos'" {
                              description
                                "../type = 'MATCH_TYPE_COS'";
                            }
                            description
                              "Match CoS array";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container cos

                          container cos-inr {
                            when
                              "../type = 'match-type-cos-inner'" {
                              description
                                "../type = 'MATCH_TYPE_COS_INNER'";
                            }
                            description
                              "Match inner header CoS";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container cos-inr

                          container dei {
                            when
                              "../type = 'match-type-dei'" {
                              description
                                "../type = 'MATCH_TYPE_DEI'";
                            }
                            description
                              "Match DEI Bit";
                            leaf bit-value {
                              type uint32;
                              description
                                "Value of the DEI bit";
                            }
                          }  // container dei

                          container dei-inr {
                            when
                              "../type = 'match-type-dei-inner'" {
                              description
                                "../type = 'MATCH_TYPE_DEI_INNER'";
                            }
                            description
                              "Match inner DEI Bit";
                            leaf bit-value {
                              type uint32;
                              description
                                "Value of the DEI bit";
                            }
                          }  // container dei-inr

                          container vlan {
                            when
                              "../type = 'match-type-vlan'" {
                              description
                                "../type = 'MATCH_TYPE_VLAN'";
                            }
                            description
                              "Match VLAN array";
                            list vlan-id-array {
                              description
                                "vlan id array";
                              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";
                              }
                            }  // list 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";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            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
                          }  // container src-mac

                          container dst-mac {
                            when
                              "../type = 'match-type-dst-mac'" {
                              description
                                "../type = 'MATCH_TYPE_DST_MAC'";
                            }
                            description
                              "Match Destination MAC address";
                            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
                          }  // container dst-mac

                          container atm-clp {
                            when
                              "../type = 'match-type-atm-clp'" {
                              description
                                "../type = 'MATCH_TYPE_ATM_CLP'";
                            }
                            description
                              "Match ATM CLP level";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "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";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container fr-de

                          container ipv4-acl {
                            when
                              "../type = 'match-type-ipv4-acl'" {
                              description
                                "../type = 'MATCH_TYPE_IPV4_ACL'";
                            }
                            description
                              "IPv4 Access-list";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container ipv4-acl

                          container ipv6-acl {
                            when
                              "../type = 'match-type-ipv6-acl'" {
                              description
                                "../type = 'MATCH_TYPE_IPV6_ACL'";
                            }
                            description
                              "IPv6 Access-list";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container ether-service-acl

                          container avail-id {
                            when
                              "../type = 'match-type-avail-id'" {
                              description
                                "../type = 'MATCH_TYPE_AVAIL_ID'";
                            }
                            description
                              "Available Identifiers";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container avail-id

                          container media-type {
                            when
                              "../type = 'match-type-media'" {
                              description
                                "../type = 'MATCH_TYPE_MEDIA'";
                            }
                            description
                              "Media Type";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container media-type

                          container subs-protocol {
                            when
                              "../type = 'match-type-subs-protocol'" {
                              description
                                "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                            }
                            description
                              "Protocol";
                            leaf-list uint8_array {
                              type uint8;
                              description
                                "uint8 array";
                            }
                          }  // container subs-protocol

                          container dnis {
                            when
                              "../type = 'match-type-dnis'" {
                              description
                                "../type = 'MATCH_TYPE_DNIS'";
                            }
                            description
                              "DNIS";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container dnis

                          container dnis-regex {
                            when
                              "../type = 'match-type-dnis-regexp'" {
                              description
                                "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                            }
                            description
                              "DNIS Regular Expression";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container dnis-regex

                          container domain {
                            when
                              "../type = 'match-type-domain'" {
                              description
                                "../type = 'MATCH_TYPE_DOMAIN'";
                            }
                            description
                              "Domain Name";
                            list domain-array {
                              description
                                "domain array";
                              leaf domain-name {
                                type string;
                                description
                                  "domain name";
                              }

                              leaf format-name {
                                type string;
                                description
                                  "format name";
                              }
                            }  // list domain-array
                          }  // container domain

                          container domain-regex {
                            when
                              "../type = 'match-type-domain-regexp'" {
                              description
                                "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                            }
                            description
                              "Domain Regular Expression";
                            list domain-array {
                              description
                                "domain array";
                              leaf domain-name {
                                type string;
                                description
                                  "domain name";
                              }

                              leaf format-name {
                                type string;
                                description
                                  "format name";
                              }
                            }  // list domain-array
                          }  // container domain-regex

                          container nas-port {
                            when
                              "../type = 'match-type-nas-port'" {
                              description
                                "../type = 'MATCH_TYPE_NAS_PORT'";
                            }
                            description
                              "NAS Port";
                            list nas-port-array {
                              description
                                "nas port array";
                              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";
                              }
                            }  // list nas-port-array
                          }  // container nas-port

                          container service-name {
                            when
                              "../type = 'match-type-service-name'" {
                              description
                                "../type = 'MATCH_TYPE_SERVICE_NAME'";
                            }
                            description
                              "Service Name";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            list ipv4-addr-array {
                              description
                                "ipv4 addr array";
                              leaf prefix {
                                type inet:ipv4-address;
                                description
                                  "prefix";
                              }

                              leaf mask {
                                type inet:ipv4-address;
                                description
                                  "mask";
                              }
                            }  // list 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";
                            list ipv4-addr-array {
                              description
                                "ipv4 addr array";
                              leaf prefix {
                                type inet:ipv4-address;
                                description
                                  "prefix";
                              }

                              leaf mask {
                                type inet:ipv4-address;
                                description
                                  "mask";
                              }
                            }  // list 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";
                            list ipv6-addr-array {
                              description
                                "ipv6 addr array";
                              leaf prefix {
                                type inet:ipv6-address;
                                description
                                  "IPV6 prefix";
                              }

                              leaf mask {
                                type uint32;
                                description
                                  "IPV6 mask";
                              }
                            }  // list 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";
                            list ipv6-addr-array {
                              description
                                "ipv6 addr array";
                              leaf prefix {
                                type inet:ipv6-address;
                                description
                                  "IPV6 prefix";
                              }

                              leaf mask {
                                type uint32;
                                description
                                  "IPV6 mask";
                              }
                            }  // list 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";
                            list mac-addr-array {
                              description
                                "mac addr array";
                              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
                            }  // list mac-addr-array
                          }  // container src-addr-mac

                          container timer {
                            when
                              "../type = 'match-type-timer'" {
                              description
                                "../type = 'MATCH_TYPE_TIMER'";
                            }
                            description
                              "Timer";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container timer

                          container timer-regexp {
                            when
                              "../type = 'match-type-timer-regexp'" {
                              description
                                "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                            }
                            description
                              "Timer Regular Expression";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container timer-regexp

                          container tunnel-name {
                            when
                              "../type = 'match-type-tunnel-name'" {
                              description
                                "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                            }
                            description
                              "Tunnel Name";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container tunnel-name-regex

                          container user-name {
                            when
                              "../type = 'match-type-user-name'" {
                              description
                                "../type = 'MATCH_TYPE_USERNAME'";
                            }
                            description
                              "User Name";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container unauth-domain-regex

                          container vendor-id {
                            when
                              "../type = 'match-type-vendor-id'" {
                              description
                                "../type = 'MATCH_TYPE_VENDOR_ID'";
                            }
                            description
                              "Vendor ID";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container vendor-id-regex

                          container access-interface {
                            when
                              "../type = 'match-type-access-interface'" {
                              description
                                "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                            }
                            description
                              "Access interface";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container access-interface

                          container input-interface {
                            when
                              "../type = 'match-type-input-interface'" {
                              description
                                "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                            }
                            description
                              "Input interface";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container input-interface

                          container ethertype {
                            when
                              "../type = 'match-type-ether-type'" {
                              description
                                "../type = 'MATCH_TYPE_ETHERTYPE'";
                            }
                            description
                              "Ethernet type";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                            container flow-keys {
                              description
                                "flow keys";
                              leaf keys {
                                type yang:hex-string;
                                description
                                  "keys";
                              }

                              leaf num {
                                type uint8;
                                description
                                  "num";
                              }
                            }  // 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)";
                            }
                          }  // 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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container circuit-id-regex

                          container remote-id {
                            when
                              "../type = 'match-type-remote-id'" {
                              description
                                "../type = 'MATCH_TYPE_REMOTE_ID'";
                            }
                            description
                              "Remote ID";
                            leaf-list string-array {
                              type string;
                              description
                                "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";
                            leaf-list string-array {
                              type string;
                              description
                                "string array";
                            }
                          }  // container remote-id-regex

                          container src-port {
                            when
                              "../type = 'match-type-src-port'" {
                              description
                                "../type = 'MATCH_TYPE_SRC_PORT'";
                            }
                            description
                              "Source port";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list uint16_rng_array
                          }  // container src-port

                          container dst-port {
                            when
                              "../type = 'match-type-dst-port'" {
                              description
                                "../type = 'MATCH_TYPE_DST_PORT'";
                            }
                            description
                              "Destination port";
                            list uint16_rng_array {
                              description
                                "uint16 rng array";
                              leaf min {
                                type uint16;
                                description
                                  "Lower limit of the range";
                              }

                              leaf max {
                                type uint16;
                                description
                                  "Upper limit of the range";
                              }
                            }  // list 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";
                          }
                        }  // container match-data

                        leaf flags {
                          type uint32;
                          description
                            "Flags";
                        }
                      }  // list 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
                }  // 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";
                  }

                  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";
                    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";
                    }
                  }  // list reference

                  list objects {
                    description
                      "Each object details";
                    leaf object-name {
                      type string {
                        length "0..64";
                      }
                      description
                        "Name of object (Policymap/Classmap)";
                    }
                  }  // list objects

                  list class-map-reference {
                    description
                      "Each Classmapdetails";
                    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";
                      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";
                      }
                    }  // list policy-map-reference
                  }  // list class-map-reference
                }  // 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

        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";
                      }

                      list policy-map-bg {
                        description
                          "policy map bg";
                        container pmap-var-list {
                          description
                            "contains variable argument data";
                          list pmap-var-list-arr {
                            description
                              "pmap var list arr";
                            container val {
                              description
                                "val";
                              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";
                              }
                            }  // container val

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

                            leaf id {
                              type uint32;
                              description
                                "id";
                            }
                          }  // list pmap-var-list-arr
                        }  // container pmap-var-list

                        container event-infop {
                          description
                            "event infop";
                          list policy-event-info-bg {
                            description
                              "policy event info bg";
                            container class-infop {
                              description
                                "class infop";
                              list policy-class-info-bg {
                                description
                                  "policy class info bg";
                                container clmp-p {
                                  description
                                    "clmp p";
                                  list class-map-bg {
                                    description
                                      "class map bg";
                                    container match-infop {
                                      description
                                        "Pointer to the first Match info";
                                      list class-match-info-st {
                                        description
                                          "class match info st";
                                        container match-data {
                                          description
                                            "Match criteria";
                                          container ipv4-dscp {
                                            when
                                              "../type = 'match-type-ipv4-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                            }
                                            description
                                              "IPv4 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv4-dscp

                                          container ipv6-dscp {
                                            when
                                              "../type = 'match-type-ipv6-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                            }
                                            description
                                              "IPv6 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv6-dscp

                                          container dscp {
                                            when
                                              "../type = 'match-type-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DSCP'";
                                            }
                                            description
                                              "Match DSCP range array";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container dscp

                                          container ipv4-prec {
                                            when
                                              "../type = 'match-type-ipv4-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_PREC'";
                                            }
                                            description
                                              "IPv4 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv4-prec

                                          container ipv6-prec {
                                            when
                                              "../type = 'match-type-ipv6-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_PREC'";
                                            }
                                            description
                                              "IPv6 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv6-prec

                                          container prec {
                                            when
                                              "../type = 'match-type-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_PREC'";
                                            }
                                            description
                                              "Match Precedence array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container prec

                                          container discard-class {
                                            when
                                              "../type = 'match-type-disc-cls'" {
                                              description
                                                "../type = 'MATCH_TYPE_DISC_CLS'";
                                            }
                                            description
                                              "Match Discard Class array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container traffic-class

                                          container proto {
                                            when
                                              "../type = 'match-type-proto'" {
                                              description
                                                "../type = 'MATCH_TYPE_PROTO'";
                                            }
                                            description
                                              "Match Protocol array";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf value {
                                              type uint16;
                                              description
                                                "Value of TCP flag";
                                            }

                                            leaf match-any {
                                              type boolean;
                                              description
                                                "Match any TCP flag bit";
                                            }
                                          }  // container tcp-flag

                                          container icmpv4-type {
                                            when
                                              "../type = 'match-type-icmpv4-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                            }
                                            description
                                              "Match ipv4 icmp type";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list uint32_rng_array {
                                              description
                                                "uint32 rng array";
                                              leaf min {
                                                type uint32;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint32;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint32_rng_array
                                          }  // container mpls-top-label

                                          container cos {
                                            when
                                              "../type = 'match-type-cos'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS'";
                                            }
                                            description
                                              "Match CoS array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos

                                          container cos-inr {
                                            when
                                              "../type = 'match-type-cos-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS_INNER'";
                                            }
                                            description
                                              "Match inner header CoS";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos-inr

                                          container dei {
                                            when
                                              "../type = 'match-type-dei'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI'";
                                            }
                                            description
                                              "Match DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei

                                          container dei-inr {
                                            when
                                              "../type = 'match-type-dei-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI_INNER'";
                                            }
                                            description
                                              "Match inner DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei-inr

                                          container vlan {
                                            when
                                              "../type = 'match-type-vlan'" {
                                              description
                                                "../type = 'MATCH_TYPE_VLAN'";
                                            }
                                            description
                                              "Match VLAN array";
                                            list vlan-id-array {
                                              description
                                                "vlan id array";
                                              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";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            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
                                          }  // container src-mac

                                          container dst-mac {
                                            when
                                              "../type = 'match-type-dst-mac'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_MAC'";
                                            }
                                            description
                                              "Match Destination MAC address";
                                            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
                                          }  // container dst-mac

                                          container atm-clp {
                                            when
                                              "../type = 'match-type-atm-clp'" {
                                              description
                                                "../type = 'MATCH_TYPE_ATM_CLP'";
                                            }
                                            description
                                              "Match ATM CLP level";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container fr-de

                                          container ipv4-acl {
                                            when
                                              "../type = 'match-type-ipv4-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_ACL'";
                                            }
                                            description
                                              "IPv4 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ipv4-acl

                                          container ipv6-acl {
                                            when
                                              "../type = 'match-type-ipv6-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_ACL'";
                                            }
                                            description
                                              "IPv6 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ether-service-acl

                                          container avail-id {
                                            when
                                              "../type = 'match-type-avail-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_AVAIL_ID'";
                                            }
                                            description
                                              "Available Identifiers";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container avail-id

                                          container media-type {
                                            when
                                              "../type = 'match-type-media'" {
                                              description
                                                "../type = 'MATCH_TYPE_MEDIA'";
                                            }
                                            description
                                              "Media Type";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container media-type

                                          container subs-protocol {
                                            when
                                              "../type = 'match-type-subs-protocol'" {
                                              description
                                                "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                            }
                                            description
                                              "Protocol";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container subs-protocol

                                          container dnis {
                                            when
                                              "../type = 'match-type-dnis'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS'";
                                            }
                                            description
                                              "DNIS";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis

                                          container dnis-regex {
                                            when
                                              "../type = 'match-type-dnis-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                            }
                                            description
                                              "DNIS Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis-regex

                                          container domain {
                                            when
                                              "../type = 'match-type-domain'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN'";
                                            }
                                            description
                                              "Domain Name";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain

                                          container domain-regex {
                                            when
                                              "../type = 'match-type-domain-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                            }
                                            description
                                              "Domain Regular Expression";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain-regex

                                          container nas-port {
                                            when
                                              "../type = 'match-type-nas-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_NAS_PORT'";
                                            }
                                            description
                                              "NAS Port";
                                            list nas-port-array {
                                              description
                                                "nas port array";
                                              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";
                                              }
                                            }  // list nas-port-array
                                          }  // container nas-port

                                          container service-name {
                                            when
                                              "../type = 'match-type-service-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                            }
                                            description
                                              "Service Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list mac-addr-array {
                                              description
                                                "mac addr array";
                                              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
                                            }  // list mac-addr-array
                                          }  // container src-addr-mac

                                          container timer {
                                            when
                                              "../type = 'match-type-timer'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER'";
                                            }
                                            description
                                              "Timer";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer

                                          container timer-regexp {
                                            when
                                              "../type = 'match-type-timer-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                            }
                                            description
                                              "Timer Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer-regexp

                                          container tunnel-name {
                                            when
                                              "../type = 'match-type-tunnel-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                            }
                                            description
                                              "Tunnel Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container tunnel-name-regex

                                          container user-name {
                                            when
                                              "../type = 'match-type-user-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_USERNAME'";
                                            }
                                            description
                                              "User Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container unauth-domain-regex

                                          container vendor-id {
                                            when
                                              "../type = 'match-type-vendor-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_VENDOR_ID'";
                                            }
                                            description
                                              "Vendor ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container vendor-id-regex

                                          container access-interface {
                                            when
                                              "../type = 'match-type-access-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                            }
                                            description
                                              "Access interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container access-interface

                                          container input-interface {
                                            when
                                              "../type = 'match-type-input-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                            }
                                            description
                                              "Input interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container input-interface

                                          container ethertype {
                                            when
                                              "../type = 'match-type-ether-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ETHERTYPE'";
                                            }
                                            description
                                              "Ethernet type";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            container flow-keys {
                                              description
                                                "flow keys";
                                              leaf keys {
                                                type yang:hex-string;
                                                description
                                                  "keys";
                                              }

                                              leaf num {
                                                type uint8;
                                                description
                                                  "num";
                                              }
                                            }  // 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)";
                                            }
                                          }  // 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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container circuit-id-regex

                                          container remote-id {
                                            when
                                              "../type = 'match-type-remote-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_REMOTE_ID'";
                                            }
                                            description
                                              "Remote ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container remote-id-regex

                                          container src-port {
                                            when
                                              "../type = 'match-type-src-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_SRC_PORT'";
                                            }
                                            description
                                              "Source port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint16_rng_array
                                          }  // container src-port

                                          container dst-port {
                                            when
                                              "../type = 'match-type-dst-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_PORT'";
                                            }
                                            description
                                              "Destination port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                          }
                                        }  // container match-data

                                        leaf flags {
                                          type uint32;
                                          description
                                            "Flags";
                                        }
                                      }  // list 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
                                }  // container clmp-p

                                container act-infop {
                                  description
                                    "act infop";
                                  list policy-action-info-st {
                                    description
                                      "policy action info st";
                                    container actp {
                                      description
                                        "actp";
                                      container mark {
                                        when
                                          "../type = 'policy-action-mark'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK'";
                                        }
                                        description
                                          "mark";
                                        list action-mark-info {
                                          description
                                            "action mark info";
                                          leaf type {
                                            type Mark-type-en;
                                            description
                                              "type";
                                          }

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

                                          leaf value {
                                            type uint16;
                                            description
                                              "value";
                                          }
                                        }  // list action-mark-info
                                      }  // container mark

                                      container mark2 {
                                        when
                                          "../type = 'policy-action-mark2'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK2'";
                                        }
                                        description
                                          "mark2";
                                        list action-mark2-info {
                                          description
                                            "action mark2 info";
                                          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";
                                          }
                                        }  // list action-mark2-info
                                      }  // container mark2

                                      container wred {
                                        when
                                          "../type = 'policy-action-wred'" {
                                          description
                                            "../type = 'POLICY_ACTION_WRED'";
                                        }
                                        description
                                          "wred";
                                        list action-wred-info {
                                          description
                                            "action wred info";
                                          container match-ranges {
                                            description
                                              "match ranges";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-ranges

                                          container min-threshold {
                                            description
                                              "min threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container min-threshold

                                          container max-threshold {
                                            description
                                              "max threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // 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";
                                          }
                                        }  // list action-wred-info
                                      }  // container wred

                                      container encap {
                                        when
                                          "../type = 'policy-action-encap-seq'" {
                                          description
                                            "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                        }
                                        description
                                          "encap";
                                        leaf seq {
                                          type uint8;
                                          description
                                            "seq";
                                        }
                                      }  // container encap

                                      container prio {
                                        when
                                          "../type = 'policy-action-priority'" {
                                          description
                                            "../type = 'POLICY_ACTION_PRIORITY'";
                                        }
                                        description
                                          "prio";
                                        leaf prio-lvl {
                                          type uint32;
                                          description
                                            "prio lvl";
                                        }
                                      }  // container prio

                                      container bwrem {
                                        when
                                          "../type = 'policy-action-bw-remaining'" {
                                          description
                                            "../type = 'POLICY_ACTION_BW_REMAINING'";
                                        }
                                        description
                                          "bwrem";
                                        container bwrem {
                                          description
                                            "bwrem";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bwrem
                                      }  // container bwrem

                                      container min-bw {
                                        when
                                          "../type = 'policy-action-min-bw'" {
                                          description
                                            "../type = 'POLICY_ACTION_MIN_BW'";
                                        }
                                        description
                                          "min bw";
                                        container bw {
                                          description
                                            "bw";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bw
                                      }  // container min-bw

                                      container authen-aaa {
                                        when
                                          "../type = 'policy-action-authenticate-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                        }
                                        description
                                          "authen aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf authen-password {
                                          type string;
                                          description
                                            "authen password";
                                        }
                                      }  // container authen-aaa

                                      container collect-id {
                                        when
                                          "../type = 'policy-action-collect-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_COLLECT_ID'";
                                        }
                                        description
                                          "collect id";
                                        leaf id {
                                          type Identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container collect-id

                                      container decode-id {
                                        when
                                          "../type = 'policy-action-decode-identifier'" {
                                          description
                                            "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                        }
                                        description
                                          "decode id";
                                        leaf id {
                                          type Decode-identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf format-name {
                                          type string;
                                          description
                                            "format name";
                                        }
                                      }  // container decode-id

                                      container set-timer {
                                        when
                                          "../type = 'policy-action-set-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_SET_TIMER'";
                                        }
                                        description
                                          "set timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }

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

                                        leaf absolute-time {
                                          type string;
                                          description
                                            "absolute time";
                                        }
                                      }  // container set-timer

                                      container stop-timer {
                                        when
                                          "../type = 'policy-action-stop-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_STOP_TIMER'";
                                        }
                                        description
                                          "stop timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }
                                      }  // 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";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container acct-aaa-list

                                      container query-ancp {
                                        when
                                          "../type = 'policy-action-query-ancp'" {
                                          description
                                            "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                        }
                                        description
                                          "query ancp";
                                        leaf enable {
                                          type boolean;
                                          description
                                            "enable";
                                        }
                                      }  // container query-ancp

                                      container prepaid-cfg {
                                        when
                                          "../type = 'policy-action-prepaid-config'" {
                                          description
                                            "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                        }
                                        description
                                          "prepaid cfg";
                                        leaf prepaid-config-profile-name {
                                          type string;
                                          description
                                            "prepaid config profile name";
                                        }
                                      }  // container prepaid-cfg

                                      container timeout-idle {
                                        when
                                          "../type = 'policy-action-timeout-idle'" {
                                          description
                                            "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                        }
                                        description
                                          "timeout idle";
                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container timeout-idle

                                      container proxy-aaa {
                                        when
                                          "../type = 'policy-action-proxy-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_PROXY_AAA'";
                                        }
                                        description
                                          "proxy aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container proxy-aaa

                                      container act-template {
                                        when
                                          "../type = 'policy-action-template-activate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                        }
                                        description
                                          "act template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container act-template

                                      container deact-template {
                                        when
                                          "../type = 'policy-action-template-deactivate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                        }
                                        description
                                          "deact template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container deact-template

                                      container qlimit {
                                        when
                                          "../type = 'policy-action-q-limit'" {
                                          description
                                            "../type = 'POLICY_ACTION_Q_LIMIT'";
                                        }
                                        description
                                          "qlimit";
                                        list action-qlimit-info-array {
                                          description
                                            "action qlimit info array";
                                          container qlim {
                                            description
                                              "qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container qlim

                                          container atmclp-qlim {
                                            description
                                              "atmclp qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container atmclp-qlim

                                          container match-values {
                                            description
                                              "match values";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-values

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

                                          leaf qlimit-flags {
                                            type uint32;
                                            description
                                              "qlimit flags";
                                          }
                                        }  // list 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";
                                        leaf action {
                                          type Acct-en;
                                          description
                                            "action";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container accounting-event-aaa

                                      container authorize-id {
                                        when
                                          "../type = 'policy-action-authorize-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                        }
                                        description
                                          "authorize id";
                                        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";
                                        }
                                      }  // container authorize-id

                                      container afm-react {
                                        when
                                          "../type = 'policy-action-afmon-react'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_REACT'";
                                        }
                                        description
                                          "afm react";
                                        list action-afmon-react-info {
                                          description
                                            "action afmon react info";
                                          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";
                                          }
                                        }  // list action-afmon-react-info
                                      }  // container afm-react

                                      container httpr {
                                        when
                                          "../type = 'policy-action-httpr'" {
                                          description
                                            "../type = 'POLICY_ACTION_HTTPR'";
                                        }
                                        description
                                          "httpr";
                                        leaf redirect-url {
                                          type string;
                                          description
                                            "redirect url";
                                        }
                                      }  // container httpr

                                      container punt {
                                        when
                                          "../type = 'policy-action-punt'" {
                                          description
                                            "../type = 'POLICY_ACTION_PUNT'";
                                        }
                                        description
                                          "punt";
                                        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";
                                        }
                                      }  // container punt

                                      container copy {
                                        when
                                          "../type = 'policy-action-copy'" {
                                          description
                                            "../type = 'POLICY_ACTION_COPY'";
                                        }
                                        description
                                          "copy";
                                        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";
                                        }
                                      }  // container copy

                                      container sfrag {
                                        when
                                          "../type = 'policy-action-sfrag'" {
                                          description
                                            "../type = 'POLICY_ACTION_SFRAG'";
                                        }
                                        description
                                          "sfrag";
                                        leaf name {
                                          type string;
                                          description
                                            "Service Fragment Name";
                                        }
                                      }  // container sfrag

                                      container redirect {
                                        when
                                          "../type = 'policy-action-redirect'" {
                                          description
                                            "../type = 'POLICY_ACTION_REDIRECT'";
                                        }
                                        description
                                          "redirect";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf type {
                                          type Redirect-type-e;
                                          description
                                            "type";
                                        }
                                      }  // container redirect

                                      container out-intf {
                                        when
                                          "../type = 'policy-action-output-interface'" {
                                          description
                                            "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                        }
                                        description
                                          "out intf";
                                        leaf out-ifname {
                                          type string;
                                          description
                                            "output interface name";
                                        }
                                      }  // container out-intf

                                      container serv-func {
                                        when
                                          "../type = 'policy-action-service-function-path'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                        }
                                        description
                                          "serv func";
                                        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";
                                        }
                                      }  // 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";
                                        list action-police-info-st {
                                          description
                                            "action police info array";
                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

                                          container burst {
                                            description
                                              "burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container burst

                                          container peak-rate {
                                            description
                                              "peak rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-rate

                                          container peak-burst {
                                            description
                                              "peak burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-burst

                                          container cdvt {
                                            description
                                              "cdvt";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container cdvt

                                          container conform-actns {
                                            description
                                              "conform actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container conform-actns

                                          container exceed-actns {
                                            description
                                              "exceed actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container exceed-actns

                                          container violate-actns {
                                            description
                                              "violate actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container violate-actns

                                          container confclass-p {
                                            description
                                              "confclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // container confclass-p

                                          container excdclass-p {
                                            description
                                              "excdclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // 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";
                                          }
                                        }  // list action-police-info-st
                                      }  // container police

                                      container shape {
                                        when
                                          "../type = 'policy-action-shape'" {
                                          description
                                            "../type = 'POLICY_ACTION_SHAPE'";
                                        }
                                        description
                                          "shape";
                                        list action-shape-info-st {
                                          description
                                            "action police info array";
                                          container bw {
                                            description
                                              "bw";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container bw

                                          container be {
                                            description
                                              "be";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container be
                                        }  // list action-shape-info-st
                                      }  // container shape

                                      container child-policy {
                                        when
                                          "../type = 'policy-action-serv-pol'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERV_POL'";
                                        }
                                        description
                                          "child policy";
                                        list action-policy-info-st {
                                          description
                                            "child policy info";
                                          container info {
                                            when
                                              "../enc = 'policy-obj-enc-name'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_NAME'";
                                            }
                                            description
                                              "info";
                                            leaf name {
                                              type Policy-map-name;
                                              description
                                                "name";
                                            }

                                            leaf type {
                                              type Policy-map-type-en;
                                              description
                                                "type";
                                            }
                                          }  // container info

                                          container hd-info {
                                            when
                                              "../enc = 'policy-obj-enc-hdl'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_HDL'";
                                            }
                                            description
                                              "hd info";
                                            container data-hd {
                                              description
                                                "data hd";
                                              list policy-map-name-type {
                                                description
                                                  "policy map type and name";
                                                leaf name {
                                                  type Policy-map-name;
                                                  description
                                                    "name";
                                                }

                                                leaf type {
                                                  type Policy-map-type-en;
                                                  description
                                                    "type";
                                                }
                                              }  // list policy-map-name-type
                                            }  // container data-hd
                                          }  // container hd-info

                                          leaf enc {
                                            type Policy-obj-enc-en;
                                            description
                                              "enc";
                                          }
                                        }  // list action-policy-info-st
                                      }  // container child-policy

                                      container cac {
                                        when
                                          "../type = 'policy-action-cac'" {
                                          description
                                            "../type = 'POLICY_ACTION_CAC'";
                                        }
                                        description
                                          "cac";
                                        list action-cac-info-st {
                                          description
                                            "action cac info st";
                                          container flow-rate {
                                            description
                                              "flow rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container flow-rate

                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

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

                                          leaf idle-timeout {
                                            type uint16;
                                            description
                                              "idle timeout";
                                          }
                                        }  // list action-cac-info-st
                                      }  // container cac

                                      container pfc {
                                        when
                                          "../type = 'policy-action-pfc'" {
                                          description
                                            "../type = 'POLICY_ACTION_PFC'";
                                        }
                                        description
                                          "pfc";
                                        list action-pfc-info-st {
                                          description
                                            "action pfc info st";
                                          container buffer-size {
                                            description
                                              "buffer size";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container buffer-size

                                          container pause-threshold {
                                            description
                                              "pause threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container pause-threshold

                                          container resume-threshold {
                                            description
                                              "resume threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container resume-threshold

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

                                          leaf buffer-size-flag {
                                            type uint32;
                                            description
                                              "buffer size flag";
                                          }
                                        }  // list action-pfc-info-st
                                      }  // container pfc

                                      container flow-parm {
                                        when
                                          "../type = 'policy-action-afmon-flow-parm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                        }
                                        description
                                          "flow parm";
                                        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";
                                        }
                                      }  // container flow-parm

                                      container ipcbr {
                                        when
                                          "../type = 'policy-action-afmon-ipcbr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                        }
                                        description
                                          "ipcbr";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container ip-bit-rate

                                        container media-bit-rate {
                                          description
                                            "media data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container ipcbr

                                      container rtp {
                                        when
                                          "../type = 'policy-action-afmon-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                        }
                                        description
                                          "rtp";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp

                                      container rtp-mmr {
                                        when
                                          "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                        }
                                        description
                                          "rtp mmr";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp-voice

                                      container mdi {
                                        when
                                          "../type = 'policy-action-afmon-mdi-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                        }
                                        description
                                          "mdi";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi

                                      container mdi-rtp {
                                        when
                                          "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                        }
                                        description
                                          "mdi rtp";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi-rtp

                                      container fmm {
                                        when
                                          "../type = 'policy-action-afmon-fmm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FMM'";
                                        }
                                        description
                                          "fmm";
                                        leaf fmm-name {
                                          type string {
                                            length
                                              "0..33";
                                          }
                                          description
                                            "flow monitor name";
                                        }
                                      }  // container fmm

                                      container pbf {
                                        when
                                          "../type = 'policy-action-pbr-next-hop'" {
                                          description
                                            "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                        }
                                        description
                                          "pbf";
                                        list action-pbf-info-array {
                                          description
                                            "action pbf info array";
                                          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";
                                          }
                                        }  // list action-pbf-info-array
                                      }  // container pbf

                                      container ipv4-nh {
                                        when
                                          "../type = 'policy-action-ipv4-nh'" {
                                          description
                                            "../type = 'POLICY_ACTION_IPV4_NH'";
                                        }
                                        description
                                          "ipv4 nh";
                                        list action-ipv4-nh-info-array {
                                          description
                                            "action ipv4 nh info array";
                                          leaf ipv4-nh-addr {
                                            type inet:ipv4-address;
                                            description
                                              "nh addr";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                        list action-ipv6-nh-info-array {
                                          description
                                            "action ipv6 nh info array";
                                          leaf ipv6-nh-addr {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 Address";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                      }
                                    }  // container actp

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

                                    leaf flags {
                                      type uint16;
                                      description
                                        "flags";
                                    }
                                  }  // list policy-action-info-st
                                }  // container act-infop

                                container nlri-infop {
                                  description
                                    "nlri info pointer";
                                  container nlri {
                                    description
                                      "nlri value";
                                    leaf-list uint8_array {
                                      type uint8;
                                      description
                                        "uint8 array";
                                    }
                                  }  // container nlri
                                }  // 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
                            }  // 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
                        }  // 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
                    }  // 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";
                      }

                      list policy-map-bg {
                        description
                          "policy map bg";
                        container pmap-var-list {
                          description
                            "contains variable argument data";
                          list pmap-var-list-arr {
                            description
                              "pmap var list arr";
                            container val {
                              description
                                "val";
                              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";
                              }
                            }  // container val

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

                            leaf id {
                              type uint32;
                              description
                                "id";
                            }
                          }  // list pmap-var-list-arr
                        }  // container pmap-var-list

                        container event-infop {
                          description
                            "event infop";
                          list policy-event-info-bg {
                            description
                              "policy event info bg";
                            container class-infop {
                              description
                                "class infop";
                              list policy-class-info-bg {
                                description
                                  "policy class info bg";
                                container clmp-p {
                                  description
                                    "clmp p";
                                  list class-map-bg {
                                    description
                                      "class map bg";
                                    container match-infop {
                                      description
                                        "Pointer to the first Match info";
                                      list class-match-info-st {
                                        description
                                          "class match info st";
                                        container match-data {
                                          description
                                            "Match criteria";
                                          container ipv4-dscp {
                                            when
                                              "../type = 'match-type-ipv4-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                            }
                                            description
                                              "IPv4 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv4-dscp

                                          container ipv6-dscp {
                                            when
                                              "../type = 'match-type-ipv6-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                            }
                                            description
                                              "IPv6 DSCP";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container ipv6-dscp

                                          container dscp {
                                            when
                                              "../type = 'match-type-dscp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DSCP'";
                                            }
                                            description
                                              "Match DSCP range array";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container dscp

                                          container ipv4-prec {
                                            when
                                              "../type = 'match-type-ipv4-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_PREC'";
                                            }
                                            description
                                              "IPv4 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv4-prec

                                          container ipv6-prec {
                                            when
                                              "../type = 'match-type-ipv6-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_PREC'";
                                            }
                                            description
                                              "IPv6 Precedence";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container ipv6-prec

                                          container prec {
                                            when
                                              "../type = 'match-type-prec'" {
                                              description
                                                "../type = 'MATCH_TYPE_PREC'";
                                            }
                                            description
                                              "Match Precedence array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container prec

                                          container discard-class {
                                            when
                                              "../type = 'match-type-disc-cls'" {
                                              description
                                                "../type = 'MATCH_TYPE_DISC_CLS'";
                                            }
                                            description
                                              "Match Discard Class array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container traffic-class

                                          container proto {
                                            when
                                              "../type = 'match-type-proto'" {
                                              description
                                                "../type = 'MATCH_TYPE_PROTO'";
                                            }
                                            description
                                              "Match Protocol array";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf value {
                                              type uint16;
                                              description
                                                "Value of TCP flag";
                                            }

                                            leaf match-any {
                                              type boolean;
                                              description
                                                "Match any TCP flag bit";
                                            }
                                          }  // container tcp-flag

                                          container icmpv4-type {
                                            when
                                              "../type = 'match-type-icmpv4-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                            }
                                            description
                                              "Match ipv4 icmp type";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list uint32_rng_array {
                                              description
                                                "uint32 rng array";
                                              leaf min {
                                                type uint32;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint32;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint32_rng_array
                                          }  // container mpls-top-label

                                          container cos {
                                            when
                                              "../type = 'match-type-cos'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS'";
                                            }
                                            description
                                              "Match CoS array";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos

                                          container cos-inr {
                                            when
                                              "../type = 'match-type-cos-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_COS_INNER'";
                                            }
                                            description
                                              "Match inner header CoS";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container cos-inr

                                          container dei {
                                            when
                                              "../type = 'match-type-dei'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI'";
                                            }
                                            description
                                              "Match DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei

                                          container dei-inr {
                                            when
                                              "../type = 'match-type-dei-inner'" {
                                              description
                                                "../type = 'MATCH_TYPE_DEI_INNER'";
                                            }
                                            description
                                              "Match inner DEI Bit";
                                            leaf bit-value {
                                              type uint32;
                                              description
                                                "Value of the DEI bit";
                                            }
                                          }  // container dei-inr

                                          container vlan {
                                            when
                                              "../type = 'match-type-vlan'" {
                                              description
                                                "../type = 'MATCH_TYPE_VLAN'";
                                            }
                                            description
                                              "Match VLAN array";
                                            list vlan-id-array {
                                              description
                                                "vlan id array";
                                              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";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            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
                                          }  // container src-mac

                                          container dst-mac {
                                            when
                                              "../type = 'match-type-dst-mac'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_MAC'";
                                            }
                                            description
                                              "Match Destination MAC address";
                                            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
                                          }  // container dst-mac

                                          container atm-clp {
                                            when
                                              "../type = 'match-type-atm-clp'" {
                                              description
                                                "../type = 'MATCH_TYPE_ATM_CLP'";
                                            }
                                            description
                                              "Match ATM CLP level";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "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";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container fr-de

                                          container ipv4-acl {
                                            when
                                              "../type = 'match-type-ipv4-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV4_ACL'";
                                            }
                                            description
                                              "IPv4 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ipv4-acl

                                          container ipv6-acl {
                                            when
                                              "../type = 'match-type-ipv6-acl'" {
                                              description
                                                "../type = 'MATCH_TYPE_IPV6_ACL'";
                                            }
                                            description
                                              "IPv6 Access-list";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container ether-service-acl

                                          container avail-id {
                                            when
                                              "../type = 'match-type-avail-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_AVAIL_ID'";
                                            }
                                            description
                                              "Available Identifiers";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container avail-id

                                          container media-type {
                                            when
                                              "../type = 'match-type-media'" {
                                              description
                                                "../type = 'MATCH_TYPE_MEDIA'";
                                            }
                                            description
                                              "Media Type";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container media-type

                                          container subs-protocol {
                                            when
                                              "../type = 'match-type-subs-protocol'" {
                                              description
                                                "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                            }
                                            description
                                              "Protocol";
                                            leaf-list uint8_array {
                                              type uint8;
                                              description
                                                "uint8 array";
                                            }
                                          }  // container subs-protocol

                                          container dnis {
                                            when
                                              "../type = 'match-type-dnis'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS'";
                                            }
                                            description
                                              "DNIS";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis

                                          container dnis-regex {
                                            when
                                              "../type = 'match-type-dnis-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                            }
                                            description
                                              "DNIS Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container dnis-regex

                                          container domain {
                                            when
                                              "../type = 'match-type-domain'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN'";
                                            }
                                            description
                                              "Domain Name";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain

                                          container domain-regex {
                                            when
                                              "../type = 'match-type-domain-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                            }
                                            description
                                              "Domain Regular Expression";
                                            list domain-array {
                                              description
                                                "domain array";
                                              leaf domain-name {
                                                type string;
                                                description
                                                  "domain name";
                                              }

                                              leaf format-name {
                                                type string;
                                                description
                                                  "format name";
                                              }
                                            }  // list domain-array
                                          }  // container domain-regex

                                          container nas-port {
                                            when
                                              "../type = 'match-type-nas-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_NAS_PORT'";
                                            }
                                            description
                                              "NAS Port";
                                            list nas-port-array {
                                              description
                                                "nas port array";
                                              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";
                                              }
                                            }  // list nas-port-array
                                          }  // container nas-port

                                          container service-name {
                                            when
                                              "../type = 'match-type-service-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                            }
                                            description
                                              "Service Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv4-addr-array {
                                              description
                                                "ipv4 addr array";
                                              leaf prefix {
                                                type inet:ipv4-address;
                                                description
                                                  "prefix";
                                              }

                                              leaf mask {
                                                type inet:ipv4-address;
                                                description
                                                  "mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list ipv6-addr-array {
                                              description
                                                "ipv6 addr array";
                                              leaf prefix {
                                                type inet:ipv6-address;
                                                description
                                                  "IPV6 prefix";
                                              }

                                              leaf mask {
                                                type uint32;
                                                description
                                                  "IPV6 mask";
                                              }
                                            }  // list 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";
                                            list mac-addr-array {
                                              description
                                                "mac addr array";
                                              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
                                            }  // list mac-addr-array
                                          }  // container src-addr-mac

                                          container timer {
                                            when
                                              "../type = 'match-type-timer'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER'";
                                            }
                                            description
                                              "Timer";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer

                                          container timer-regexp {
                                            when
                                              "../type = 'match-type-timer-regexp'" {
                                              description
                                                "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                            }
                                            description
                                              "Timer Regular Expression";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container timer-regexp

                                          container tunnel-name {
                                            when
                                              "../type = 'match-type-tunnel-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                            }
                                            description
                                              "Tunnel Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container tunnel-name-regex

                                          container user-name {
                                            when
                                              "../type = 'match-type-user-name'" {
                                              description
                                                "../type = 'MATCH_TYPE_USERNAME'";
                                            }
                                            description
                                              "User Name";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container unauth-domain-regex

                                          container vendor-id {
                                            when
                                              "../type = 'match-type-vendor-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_VENDOR_ID'";
                                            }
                                            description
                                              "Vendor ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container vendor-id-regex

                                          container access-interface {
                                            when
                                              "../type = 'match-type-access-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                            }
                                            description
                                              "Access interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container access-interface

                                          container input-interface {
                                            when
                                              "../type = 'match-type-input-interface'" {
                                              description
                                                "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                            }
                                            description
                                              "Input interface";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container input-interface

                                          container ethertype {
                                            when
                                              "../type = 'match-type-ether-type'" {
                                              description
                                                "../type = 'MATCH_TYPE_ETHERTYPE'";
                                            }
                                            description
                                              "Ethernet type";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                            container flow-keys {
                                              description
                                                "flow keys";
                                              leaf keys {
                                                type yang:hex-string;
                                                description
                                                  "keys";
                                              }

                                              leaf num {
                                                type uint8;
                                                description
                                                  "num";
                                              }
                                            }  // 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)";
                                            }
                                          }  // 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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container circuit-id-regex

                                          container remote-id {
                                            when
                                              "../type = 'match-type-remote-id'" {
                                              description
                                                "../type = 'MATCH_TYPE_REMOTE_ID'";
                                            }
                                            description
                                              "Remote ID";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "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";
                                            leaf-list string-array {
                                              type string;
                                              description
                                                "string array";
                                            }
                                          }  // container remote-id-regex

                                          container src-port {
                                            when
                                              "../type = 'match-type-src-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_SRC_PORT'";
                                            }
                                            description
                                              "Source port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint16_rng_array
                                          }  // container src-port

                                          container dst-port {
                                            when
                                              "../type = 'match-type-dst-port'" {
                                              description
                                                "../type = 'MATCH_TYPE_DST_PORT'";
                                            }
                                            description
                                              "Destination port";
                                            list uint16_rng_array {
                                              description
                                                "uint16 rng array";
                                              leaf min {
                                                type uint16;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint16;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list 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";
                                          }
                                        }  // container match-data

                                        leaf flags {
                                          type uint32;
                                          description
                                            "Flags";
                                        }
                                      }  // list 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
                                }  // container clmp-p

                                container act-infop {
                                  description
                                    "act infop";
                                  list policy-action-info-st {
                                    description
                                      "policy action info st";
                                    container actp {
                                      description
                                        "actp";
                                      container mark {
                                        when
                                          "../type = 'policy-action-mark'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK'";
                                        }
                                        description
                                          "mark";
                                        list action-mark-info {
                                          description
                                            "action mark info";
                                          leaf type {
                                            type Mark-type-en;
                                            description
                                              "type";
                                          }

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

                                          leaf value {
                                            type uint16;
                                            description
                                              "value";
                                          }
                                        }  // list action-mark-info
                                      }  // container mark

                                      container mark2 {
                                        when
                                          "../type = 'policy-action-mark2'" {
                                          description
                                            "../type = 'POLICY_ACTION_MARK2'";
                                        }
                                        description
                                          "mark2";
                                        list action-mark2-info {
                                          description
                                            "action mark2 info";
                                          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";
                                          }
                                        }  // list action-mark2-info
                                      }  // container mark2

                                      container wred {
                                        when
                                          "../type = 'policy-action-wred'" {
                                          description
                                            "../type = 'POLICY_ACTION_WRED'";
                                        }
                                        description
                                          "wred";
                                        list action-wred-info {
                                          description
                                            "action wred info";
                                          container match-ranges {
                                            description
                                              "match ranges";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-ranges

                                          container min-threshold {
                                            description
                                              "min threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container min-threshold

                                          container max-threshold {
                                            description
                                              "max threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // 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";
                                          }
                                        }  // list action-wred-info
                                      }  // container wred

                                      container encap {
                                        when
                                          "../type = 'policy-action-encap-seq'" {
                                          description
                                            "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                        }
                                        description
                                          "encap";
                                        leaf seq {
                                          type uint8;
                                          description
                                            "seq";
                                        }
                                      }  // container encap

                                      container prio {
                                        when
                                          "../type = 'policy-action-priority'" {
                                          description
                                            "../type = 'POLICY_ACTION_PRIORITY'";
                                        }
                                        description
                                          "prio";
                                        leaf prio-lvl {
                                          type uint32;
                                          description
                                            "prio lvl";
                                        }
                                      }  // container prio

                                      container bwrem {
                                        when
                                          "../type = 'policy-action-bw-remaining'" {
                                          description
                                            "../type = 'POLICY_ACTION_BW_REMAINING'";
                                        }
                                        description
                                          "bwrem";
                                        container bwrem {
                                          description
                                            "bwrem";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bwrem
                                      }  // container bwrem

                                      container min-bw {
                                        when
                                          "../type = 'policy-action-min-bw'" {
                                          description
                                            "../type = 'POLICY_ACTION_MIN_BW'";
                                        }
                                        description
                                          "min bw";
                                        container bw {
                                          description
                                            "bw";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bw
                                      }  // container min-bw

                                      container authen-aaa {
                                        when
                                          "../type = 'policy-action-authenticate-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                        }
                                        description
                                          "authen aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf authen-password {
                                          type string;
                                          description
                                            "authen password";
                                        }
                                      }  // container authen-aaa

                                      container collect-id {
                                        when
                                          "../type = 'policy-action-collect-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_COLLECT_ID'";
                                        }
                                        description
                                          "collect id";
                                        leaf id {
                                          type Identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container collect-id

                                      container decode-id {
                                        when
                                          "../type = 'policy-action-decode-identifier'" {
                                          description
                                            "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                        }
                                        description
                                          "decode id";
                                        leaf id {
                                          type Decode-identifier-en;
                                          description
                                            "id";
                                        }

                                        leaf format-name {
                                          type string;
                                          description
                                            "format name";
                                        }
                                      }  // container decode-id

                                      container set-timer {
                                        when
                                          "../type = 'policy-action-set-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_SET_TIMER'";
                                        }
                                        description
                                          "set timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }

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

                                        leaf absolute-time {
                                          type string;
                                          description
                                            "absolute time";
                                        }
                                      }  // container set-timer

                                      container stop-timer {
                                        when
                                          "../type = 'policy-action-stop-timer'" {
                                          description
                                            "../type = 'POLICY_ACTION_STOP_TIMER'";
                                        }
                                        description
                                          "stop timer";
                                        leaf timer-name {
                                          type string;
                                          description
                                            "timer name";
                                        }
                                      }  // 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";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }

                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container acct-aaa-list

                                      container query-ancp {
                                        when
                                          "../type = 'policy-action-query-ancp'" {
                                          description
                                            "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                        }
                                        description
                                          "query ancp";
                                        leaf enable {
                                          type boolean;
                                          description
                                            "enable";
                                        }
                                      }  // container query-ancp

                                      container prepaid-cfg {
                                        when
                                          "../type = 'policy-action-prepaid-config'" {
                                          description
                                            "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                        }
                                        description
                                          "prepaid cfg";
                                        leaf prepaid-config-profile-name {
                                          type string;
                                          description
                                            "prepaid config profile name";
                                        }
                                      }  // container prepaid-cfg

                                      container timeout-idle {
                                        when
                                          "../type = 'policy-action-timeout-idle'" {
                                          description
                                            "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                        }
                                        description
                                          "timeout idle";
                                        leaf secs {
                                          type uint32;
                                          description
                                            "secs";
                                        }
                                      }  // container timeout-idle

                                      container proxy-aaa {
                                        when
                                          "../type = 'policy-action-proxy-aaa'" {
                                          description
                                            "../type = 'POLICY_ACTION_PROXY_AAA'";
                                        }
                                        description
                                          "proxy aaa";
                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container proxy-aaa

                                      container act-template {
                                        when
                                          "../type = 'policy-action-template-activate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                        }
                                        description
                                          "act template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container act-template

                                      container deact-template {
                                        when
                                          "../type = 'policy-action-template-deactivate'" {
                                          description
                                            "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                        }
                                        description
                                          "deact template";
                                        leaf template-name {
                                          type string;
                                          description
                                            "template name";
                                        }

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

                                        leaf flags {
                                          type uint32;
                                          description
                                            "flags";
                                        }
                                      }  // container deact-template

                                      container qlimit {
                                        when
                                          "../type = 'policy-action-q-limit'" {
                                          description
                                            "../type = 'POLICY_ACTION_Q_LIMIT'";
                                        }
                                        description
                                          "qlimit";
                                        list action-qlimit-info-array {
                                          description
                                            "action qlimit info array";
                                          container qlim {
                                            description
                                              "qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container qlim

                                          container atmclp-qlim {
                                            description
                                              "atmclp qlim";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container atmclp-qlim

                                          container match-values {
                                            description
                                              "match values";
                                            list uint8_rng_array {
                                              description
                                                "uint8 rng array";
                                              leaf min {
                                                type uint8;
                                                description
                                                  "Lower limit of the range";
                                              }

                                              leaf max {
                                                type uint8;
                                                description
                                                  "Upper limit of the range";
                                              }
                                            }  // list uint8_rng_array
                                          }  // container match-values

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

                                          leaf qlimit-flags {
                                            type uint32;
                                            description
                                              "qlimit flags";
                                          }
                                        }  // list 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";
                                        leaf action {
                                          type Acct-en;
                                          description
                                            "action";
                                        }

                                        leaf aaa-list-name {
                                          type string;
                                          description
                                            "aaa list name";
                                        }
                                      }  // container accounting-event-aaa

                                      container authorize-id {
                                        when
                                          "../type = 'policy-action-authorize-id'" {
                                          description
                                            "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                        }
                                        description
                                          "authorize id";
                                        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";
                                        }
                                      }  // container authorize-id

                                      container afm-react {
                                        when
                                          "../type = 'policy-action-afmon-react'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_REACT'";
                                        }
                                        description
                                          "afm react";
                                        list action-afmon-react-info {
                                          description
                                            "action afmon react info";
                                          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";
                                          }
                                        }  // list action-afmon-react-info
                                      }  // container afm-react

                                      container httpr {
                                        when
                                          "../type = 'policy-action-httpr'" {
                                          description
                                            "../type = 'POLICY_ACTION_HTTPR'";
                                        }
                                        description
                                          "httpr";
                                        leaf redirect-url {
                                          type string;
                                          description
                                            "redirect url";
                                        }
                                      }  // container httpr

                                      container punt {
                                        when
                                          "../type = 'policy-action-punt'" {
                                          description
                                            "../type = 'POLICY_ACTION_PUNT'";
                                        }
                                        description
                                          "punt";
                                        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";
                                        }
                                      }  // container punt

                                      container copy {
                                        when
                                          "../type = 'policy-action-copy'" {
                                          description
                                            "../type = 'POLICY_ACTION_COPY'";
                                        }
                                        description
                                          "copy";
                                        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";
                                        }
                                      }  // container copy

                                      container sfrag {
                                        when
                                          "../type = 'policy-action-sfrag'" {
                                          description
                                            "../type = 'POLICY_ACTION_SFRAG'";
                                        }
                                        description
                                          "sfrag";
                                        leaf name {
                                          type string;
                                          description
                                            "Service Fragment Name";
                                        }
                                      }  // container sfrag

                                      container redirect {
                                        when
                                          "../type = 'policy-action-redirect'" {
                                          description
                                            "../type = 'POLICY_ACTION_REDIRECT'";
                                        }
                                        description
                                          "redirect";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf type {
                                          type Redirect-type-e;
                                          description
                                            "type";
                                        }
                                      }  // container redirect

                                      container out-intf {
                                        when
                                          "../type = 'policy-action-output-interface'" {
                                          description
                                            "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                        }
                                        description
                                          "out intf";
                                        leaf out-ifname {
                                          type string;
                                          description
                                            "output interface name";
                                        }
                                      }  // container out-intf

                                      container serv-func {
                                        when
                                          "../type = 'policy-action-service-function-path'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                        }
                                        description
                                          "serv func";
                                        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";
                                        }
                                      }  // 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";
                                        list action-police-info-st {
                                          description
                                            "action police info array";
                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

                                          container burst {
                                            description
                                              "burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container burst

                                          container peak-rate {
                                            description
                                              "peak rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-rate

                                          container peak-burst {
                                            description
                                              "peak burst";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container peak-burst

                                          container cdvt {
                                            description
                                              "cdvt";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container cdvt

                                          container conform-actns {
                                            description
                                              "conform actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container conform-actns

                                          container exceed-actns {
                                            description
                                              "exceed actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container exceed-actns

                                          container violate-actns {
                                            description
                                              "violate actns";
                                            list police-action-array {
                                              description
                                                "police action array";
                                              container mark {
                                                when
                                                  "../type = 'police-action-mark'" {
                                                  description
                                                    "../type = 'POLICE_ACTION_MARK'";
                                                }
                                                description
                                                  "mark";
                                                leaf type {
                                                  type Mark-type-en;
                                                  description
                                                    "type";
                                                }

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

                                                leaf value {
                                                  type uint16;
                                                  description
                                                    "value";
                                                }
                                              }  // container mark

                                              leaf type {
                                                type Police-action-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list police-action-array
                                          }  // container violate-actns

                                          container confclass-p {
                                            description
                                              "confclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // container confclass-p

                                          container excdclass-p {
                                            description
                                              "excdclass p";
                                            list class-map-bg {
                                              description
                                                "class map bg";
                                              container match-infop {
                                                description
                                                  "Pointer to the first Match info";
                                                list class-match-info-st {
                                                  description
                                                    "class match info st";
                                                  container match-data {
                                                    description
                                                      "Match criteria";
                                                    container ipv4-dscp {
                                                      when
                                                        "../type = 'match-type-ipv4-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                      }
                                                      description
                                                        "IPv4 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv4-dscp

                                                    container ipv6-dscp {
                                                      when
                                                        "../type = 'match-type-ipv6-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                      }
                                                      description
                                                        "IPv6 DSCP";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container ipv6-dscp

                                                    container dscp {
                                                      when
                                                        "../type = 'match-type-dscp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DSCP'";
                                                      }
                                                      description
                                                        "Match DSCP range array";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container dscp

                                                    container ipv4-prec {
                                                      when
                                                        "../type = 'match-type-ipv4-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                      }
                                                      description
                                                        "IPv4 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv4-prec

                                                    container ipv6-prec {
                                                      when
                                                        "../type = 'match-type-ipv6-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                      }
                                                      description
                                                        "IPv6 Precedence";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container ipv6-prec

                                                    container prec {
                                                      when
                                                        "../type = 'match-type-prec'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PREC'";
                                                      }
                                                      description
                                                        "Match Precedence array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container prec

                                                    container discard-class {
                                                      when
                                                        "../type = 'match-type-disc-cls'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DISC_CLS'";
                                                      }
                                                      description
                                                        "Match Discard Class array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint8_rng_array
                                                    }  // container traffic-class

                                                    container proto {
                                                      when
                                                        "../type = 'match-type-proto'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_PROTO'";
                                                      }
                                                      description
                                                        "Match Protocol array";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf value {
                                                        type uint16;
                                                        description
                                                          "Value of TCP flag";
                                                      }

                                                      leaf match-any {
                                                        type boolean;
                                                        description
                                                          "Match any TCP flag bit";
                                                      }
                                                    }  // container tcp-flag

                                                    container icmpv4-type {
                                                      when
                                                        "../type = 'match-type-icmpv4-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                      }
                                                      description
                                                        "Match ipv4 icmp type";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint8_rng_array {
                                                        description
                                                          "uint8 rng array";
                                                        leaf min {
                                                          type uint8;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint8;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list uint32_rng_array {
                                                        description
                                                          "uint32 rng array";
                                                        leaf min {
                                                          type uint32;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint32;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint32_rng_array
                                                    }  // container mpls-top-label

                                                    container cos {
                                                      when
                                                        "../type = 'match-type-cos'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS'";
                                                      }
                                                      description
                                                        "Match CoS array";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos

                                                    container cos-inr {
                                                      when
                                                        "../type = 'match-type-cos-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_COS_INNER'";
                                                      }
                                                      description
                                                        "Match inner header CoS";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container cos-inr

                                                    container dei {
                                                      when
                                                        "../type = 'match-type-dei'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI'";
                                                      }
                                                      description
                                                        "Match DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei

                                                    container dei-inr {
                                                      when
                                                        "../type = 'match-type-dei-inner'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DEI_INNER'";
                                                      }
                                                      description
                                                        "Match inner DEI Bit";
                                                      leaf bit-value {
                                                        type uint32;
                                                        description
                                                          "Value of the DEI bit";
                                                      }
                                                    }  // container dei-inr

                                                    container vlan {
                                                      when
                                                        "../type = 'match-type-vlan'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VLAN'";
                                                      }
                                                      description
                                                        "Match VLAN array";
                                                      list vlan-id-array {
                                                        description
                                                          "vlan id array";
                                                        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";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      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
                                                    }  // container src-mac

                                                    container dst-mac {
                                                      when
                                                        "../type = 'match-type-dst-mac'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_MAC'";
                                                      }
                                                      description
                                                        "Match Destination MAC address";
                                                      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
                                                    }  // container dst-mac

                                                    container atm-clp {
                                                      when
                                                        "../type = 'match-type-atm-clp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ATM_CLP'";
                                                      }
                                                      description
                                                        "Match ATM CLP level";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "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";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container fr-de

                                                    container ipv4-acl {
                                                      when
                                                        "../type = 'match-type-ipv4-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                      }
                                                      description
                                                        "IPv4 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ipv4-acl

                                                    container ipv6-acl {
                                                      when
                                                        "../type = 'match-type-ipv6-acl'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                      }
                                                      description
                                                        "IPv6 Access-list";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container ether-service-acl

                                                    container avail-id {
                                                      when
                                                        "../type = 'match-type-avail-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                      }
                                                      description
                                                        "Available Identifiers";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container avail-id

                                                    container media-type {
                                                      when
                                                        "../type = 'match-type-media'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_MEDIA'";
                                                      }
                                                      description
                                                        "Media Type";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container media-type

                                                    container subs-protocol {
                                                      when
                                                        "../type = 'match-type-subs-protocol'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                      }
                                                      description
                                                        "Protocol";
                                                      leaf-list uint8_array {
                                                        type uint8;
                                                        description
                                                          "uint8 array";
                                                      }
                                                    }  // container subs-protocol

                                                    container dnis {
                                                      when
                                                        "../type = 'match-type-dnis'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS'";
                                                      }
                                                      description
                                                        "DNIS";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis

                                                    container dnis-regex {
                                                      when
                                                        "../type = 'match-type-dnis-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                      }
                                                      description
                                                        "DNIS Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container dnis-regex

                                                    container domain {
                                                      when
                                                        "../type = 'match-type-domain'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN'";
                                                      }
                                                      description
                                                        "Domain Name";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain

                                                    container domain-regex {
                                                      when
                                                        "../type = 'match-type-domain-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                      }
                                                      description
                                                        "Domain Regular Expression";
                                                      list domain-array {
                                                        description
                                                          "domain array";
                                                        leaf domain-name {
                                                          type string;
                                                          description
                                                            "domain name";
                                                        }

                                                        leaf format-name {
                                                          type string;
                                                          description
                                                            "format name";
                                                        }
                                                      }  // list domain-array
                                                    }  // container domain-regex

                                                    container nas-port {
                                                      when
                                                        "../type = 'match-type-nas-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_NAS_PORT'";
                                                      }
                                                      description
                                                        "NAS Port";
                                                      list nas-port-array {
                                                        description
                                                          "nas port array";
                                                        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";
                                                        }
                                                      }  // list nas-port-array
                                                    }  // container nas-port

                                                    container service-name {
                                                      when
                                                        "../type = 'match-type-service-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                      }
                                                      description
                                                        "Service Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv4-addr-array {
                                                        description
                                                          "ipv4 addr array";
                                                        leaf prefix {
                                                          type inet:ipv4-address;
                                                          description
                                                            "prefix";
                                                        }

                                                        leaf mask {
                                                          type inet:ipv4-address;
                                                          description
                                                            "mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list ipv6-addr-array {
                                                        description
                                                          "ipv6 addr array";
                                                        leaf prefix {
                                                          type inet:ipv6-address;
                                                          description
                                                            "IPV6 prefix";
                                                        }

                                                        leaf mask {
                                                          type uint32;
                                                          description
                                                            "IPV6 mask";
                                                        }
                                                      }  // list 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";
                                                      list mac-addr-array {
                                                        description
                                                          "mac addr array";
                                                        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
                                                      }  // list mac-addr-array
                                                    }  // container src-addr-mac

                                                    container timer {
                                                      when
                                                        "../type = 'match-type-timer'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER'";
                                                      }
                                                      description
                                                        "Timer";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer

                                                    container timer-regexp {
                                                      when
                                                        "../type = 'match-type-timer-regexp'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                      }
                                                      description
                                                        "Timer Regular Expression";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container timer-regexp

                                                    container tunnel-name {
                                                      when
                                                        "../type = 'match-type-tunnel-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                      }
                                                      description
                                                        "Tunnel Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container tunnel-name-regex

                                                    container user-name {
                                                      when
                                                        "../type = 'match-type-user-name'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_USERNAME'";
                                                      }
                                                      description
                                                        "User Name";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container unauth-domain-regex

                                                    container vendor-id {
                                                      when
                                                        "../type = 'match-type-vendor-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                      }
                                                      description
                                                        "Vendor ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container vendor-id-regex

                                                    container access-interface {
                                                      when
                                                        "../type = 'match-type-access-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                      }
                                                      description
                                                        "Access interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container access-interface

                                                    container input-interface {
                                                      when
                                                        "../type = 'match-type-input-interface'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                      }
                                                      description
                                                        "Input interface";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container input-interface

                                                    container ethertype {
                                                      when
                                                        "../type = 'match-type-ether-type'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                      }
                                                      description
                                                        "Ethernet type";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                      container flow-keys {
                                                        description
                                                          "flow keys";
                                                        leaf keys {
                                                          type yang:hex-string;
                                                          description
                                                            "keys";
                                                        }

                                                        leaf num {
                                                          type uint8;
                                                          description
                                                            "num";
                                                        }
                                                      }  // 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)";
                                                      }
                                                    }  // 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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container circuit-id-regex

                                                    container remote-id {
                                                      when
                                                        "../type = 'match-type-remote-id'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                      }
                                                      description
                                                        "Remote ID";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "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";
                                                      leaf-list string-array {
                                                        type string;
                                                        description
                                                          "string array";
                                                      }
                                                    }  // container remote-id-regex

                                                    container src-port {
                                                      when
                                                        "../type = 'match-type-src-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_SRC_PORT'";
                                                      }
                                                      description
                                                        "Source port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list uint16_rng_array
                                                    }  // container src-port

                                                    container dst-port {
                                                      when
                                                        "../type = 'match-type-dst-port'" {
                                                        description
                                                          "../type = 'MATCH_TYPE_DST_PORT'";
                                                      }
                                                      description
                                                        "Destination port";
                                                      list uint16_rng_array {
                                                        description
                                                          "uint16 rng array";
                                                        leaf min {
                                                          type uint16;
                                                          description
                                                            "Lower limit of the range";
                                                        }

                                                        leaf max {
                                                          type uint16;
                                                          description
                                                            "Upper limit of the range";
                                                        }
                                                      }  // list 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";
                                                    }
                                                  }  // container match-data

                                                  leaf flags {
                                                    type uint32;
                                                    description
                                                      "Flags";
                                                  }
                                                }  // list 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
                                          }  // 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";
                                          }
                                        }  // list action-police-info-st
                                      }  // container police

                                      container shape {
                                        when
                                          "../type = 'policy-action-shape'" {
                                          description
                                            "../type = 'POLICY_ACTION_SHAPE'";
                                        }
                                        description
                                          "shape";
                                        list action-shape-info-st {
                                          description
                                            "action police info array";
                                          container bw {
                                            description
                                              "bw";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container bw

                                          container be {
                                            description
                                              "be";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container be
                                        }  // list action-shape-info-st
                                      }  // container shape

                                      container child-policy {
                                        when
                                          "../type = 'policy-action-serv-pol'" {
                                          description
                                            "../type = 'POLICY_ACTION_SERV_POL'";
                                        }
                                        description
                                          "child policy";
                                        list action-policy-info-st {
                                          description
                                            "child policy info";
                                          container info {
                                            when
                                              "../enc = 'policy-obj-enc-name'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_NAME'";
                                            }
                                            description
                                              "info";
                                            leaf name {
                                              type Policy-map-name;
                                              description
                                                "name";
                                            }

                                            leaf type {
                                              type Policy-map-type-en;
                                              description
                                                "type";
                                            }
                                          }  // container info

                                          container hd-info {
                                            when
                                              "../enc = 'policy-obj-enc-hdl'" {
                                              description
                                                "../enc = 'POLICY_OBJ_ENC_HDL'";
                                            }
                                            description
                                              "hd info";
                                            container data-hd {
                                              description
                                                "data hd";
                                              list policy-map-name-type {
                                                description
                                                  "policy map type and name";
                                                leaf name {
                                                  type Policy-map-name;
                                                  description
                                                    "name";
                                                }

                                                leaf type {
                                                  type Policy-map-type-en;
                                                  description
                                                    "type";
                                                }
                                              }  // list policy-map-name-type
                                            }  // container data-hd
                                          }  // container hd-info

                                          leaf enc {
                                            type Policy-obj-enc-en;
                                            description
                                              "enc";
                                          }
                                        }  // list action-policy-info-st
                                      }  // container child-policy

                                      container cac {
                                        when
                                          "../type = 'policy-action-cac'" {
                                          description
                                            "../type = 'POLICY_ACTION_CAC'";
                                        }
                                        description
                                          "cac";
                                        list action-cac-info-st {
                                          description
                                            "action cac info st";
                                          container flow-rate {
                                            description
                                              "flow rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container flow-rate

                                          container rate {
                                            description
                                              "rate";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container rate

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

                                          leaf idle-timeout {
                                            type uint16;
                                            description
                                              "idle timeout";
                                          }
                                        }  // list action-cac-info-st
                                      }  // container cac

                                      container pfc {
                                        when
                                          "../type = 'policy-action-pfc'" {
                                          description
                                            "../type = 'POLICY_ACTION_PFC'";
                                        }
                                        description
                                          "pfc";
                                        list action-pfc-info-st {
                                          description
                                            "action pfc info st";
                                          container buffer-size {
                                            description
                                              "buffer size";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container buffer-size

                                          container pause-threshold {
                                            description
                                              "pause threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container pause-threshold

                                          container resume-threshold {
                                            description
                                              "resume threshold";
                                            leaf value {
                                              type uint32;
                                              description
                                                "value";
                                            }

                                            leaf unit {
                                              type Policy-param-unit-type;
                                              description
                                                "unit";
                                            }
                                          }  // container resume-threshold

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

                                          leaf buffer-size-flag {
                                            type uint32;
                                            description
                                              "buffer size flag";
                                          }
                                        }  // list action-pfc-info-st
                                      }  // container pfc

                                      container flow-parm {
                                        when
                                          "../type = 'policy-action-afmon-flow-parm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                        }
                                        description
                                          "flow parm";
                                        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";
                                        }
                                      }  // container flow-parm

                                      container ipcbr {
                                        when
                                          "../type = 'policy-action-afmon-ipcbr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                        }
                                        description
                                          "ipcbr";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container ip-bit-rate

                                        container media-bit-rate {
                                          description
                                            "media data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container ipcbr

                                      container rtp {
                                        when
                                          "../type = 'policy-action-afmon-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                        }
                                        description
                                          "rtp";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp

                                      container rtp-mmr {
                                        when
                                          "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                        }
                                        description
                                          "rtp mmr";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // 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";
                                        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";
                                          leaf pt {
                                            type uint32;
                                            description
                                              "pt";
                                          }

                                          leaf frequency {
                                            type uint32;
                                            description
                                              "frequency";
                                          }
                                        }  // list clock-rate
                                      }  // container rtp-voice

                                      container mdi {
                                        when
                                          "../type = 'policy-action-afmon-mdi-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                        }
                                        description
                                          "mdi";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi

                                      container mdi-rtp {
                                        when
                                          "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                        }
                                        description
                                          "mdi rtp";
                                        container ip-bit-rate {
                                          description
                                            "data rate in bps";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // container mdi-rtp

                                      container fmm {
                                        when
                                          "../type = 'policy-action-afmon-fmm'" {
                                          description
                                            "../type = 'POLICY_ACTION_AFMON_FMM'";
                                        }
                                        description
                                          "fmm";
                                        leaf fmm-name {
                                          type string {
                                            length
                                              "0..33";
                                          }
                                          description
                                            "flow monitor name";
                                        }
                                      }  // container fmm

                                      container pbf {
                                        when
                                          "../type = 'policy-action-pbr-next-hop'" {
                                          description
                                            "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                        }
                                        description
                                          "pbf";
                                        list action-pbf-info-array {
                                          description
                                            "action pbf info array";
                                          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";
                                          }
                                        }  // list action-pbf-info-array
                                      }  // container pbf

                                      container ipv4-nh {
                                        when
                                          "../type = 'policy-action-ipv4-nh'" {
                                          description
                                            "../type = 'POLICY_ACTION_IPV4_NH'";
                                        }
                                        description
                                          "ipv4 nh";
                                        list action-ipv4-nh-info-array {
                                          description
                                            "action ipv4 nh info array";
                                          leaf ipv4-nh-addr {
                                            type inet:ipv4-address;
                                            description
                                              "nh addr";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                        list action-ipv6-nh-info-array {
                                          description
                                            "action ipv6 nh info array";
                                          leaf ipv6-nh-addr {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 Address";
                                          }

                                          leaf vrf-name {
                                            type string;
                                            description
                                              "Vrf name";
                                          }
                                        }  // list 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";
                                      }
                                    }  // container actp

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

                                    leaf flags {
                                      type uint16;
                                      description
                                        "flags";
                                    }
                                  }  // list policy-action-info-st
                                }  // container act-infop

                                container nlri-infop {
                                  description
                                    "nlri info pointer";
                                  container nlri {
                                    description
                                      "nlri value";
                                    leaf-list uint8_array {
                                      type uint8;
                                      description
                                        "uint8 array";
                                    }
                                  }  // container nlri
                                }  // 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
                            }  // 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
                        }  // 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
                    }  // list class-seq-num
                  }  // container class-seq-nums

                  container definition {
                    description
                      "Transient Policy-map type name";
                    list policy-map-bg {
                      description
                        "policy map bg";
                      container pmap-var-list {
                        description
                          "contains variable argument data";
                        list pmap-var-list-arr {
                          description
                            "pmap var list arr";
                          container val {
                            description
                              "val";
                            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";
                            }
                          }  // container val

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

                          leaf id {
                            type uint32;
                            description "id";
                          }
                        }  // list pmap-var-list-arr
                      }  // container pmap-var-list

                      container event-infop {
                        description
                          "event infop";
                        list policy-event-info-bg {
                          description
                            "policy event info bg";
                          container class-infop {
                            description
                              "class infop";
                            list policy-class-info-bg {
                              description
                                "policy class info bg";
                              container clmp-p {
                                description
                                  "clmp p";
                                list class-map-bg {
                                  description
                                    "class map bg";
                                  container match-infop {
                                    description
                                      "Pointer to the first Match info";
                                    list class-match-info-st {
                                      description
                                        "class match info st";
                                      container match-data {
                                        description
                                          "Match criteria";
                                        container ipv4-dscp {
                                          when
                                            "../type = 'match-type-ipv4-dscp'" {
                                            description
                                              "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                          }
                                          description
                                            "IPv4 DSCP";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint8_rng_array
                                        }  // container ipv4-dscp

                                        container ipv6-dscp {
                                          when
                                            "../type = 'match-type-ipv6-dscp'" {
                                            description
                                              "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                          }
                                          description
                                            "IPv6 DSCP";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint8_rng_array
                                        }  // container ipv6-dscp

                                        container dscp {
                                          when
                                            "../type = 'match-type-dscp'" {
                                            description
                                              "../type = 'MATCH_TYPE_DSCP'";
                                          }
                                          description
                                            "Match DSCP range array";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint8_rng_array
                                        }  // container dscp

                                        container ipv4-prec {
                                          when
                                            "../type = 'match-type-ipv4-prec'" {
                                            description
                                              "../type = 'MATCH_TYPE_IPV4_PREC'";
                                          }
                                          description
                                            "IPv4 Precedence";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container ipv4-prec

                                        container ipv6-prec {
                                          when
                                            "../type = 'match-type-ipv6-prec'" {
                                            description
                                              "../type = 'MATCH_TYPE_IPV6_PREC'";
                                          }
                                          description
                                            "IPv6 Precedence";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container ipv6-prec

                                        container prec {
                                          when
                                            "../type = 'match-type-prec'" {
                                            description
                                              "../type = 'MATCH_TYPE_PREC'";
                                          }
                                          description
                                            "Match Precedence array";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container prec

                                        container discard-class {
                                          when
                                            "../type = 'match-type-disc-cls'" {
                                            description
                                              "../type = 'MATCH_TYPE_DISC_CLS'";
                                          }
                                          description
                                            "Match Discard Class array";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "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";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint8_rng_array
                                        }  // container traffic-class

                                        container proto {
                                          when
                                            "../type = 'match-type-proto'" {
                                            description
                                              "../type = 'MATCH_TYPE_PROTO'";
                                          }
                                          description
                                            "Match Protocol array";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          leaf value {
                                            type uint16;
                                            description
                                              "Value of TCP flag";
                                          }

                                          leaf match-any {
                                            type boolean;
                                            description
                                              "Match any TCP flag bit";
                                          }
                                        }  // container tcp-flag

                                        container icmpv4-type {
                                          when
                                            "../type = 'match-type-icmpv4-type'" {
                                            description
                                              "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                          }
                                          description
                                            "Match ipv4 icmp type";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "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";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          list uint32_rng_array {
                                            description
                                              "uint32 rng array";
                                            leaf min {
                                              type uint32;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint32;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint32_rng_array
                                        }  // container mpls-top-label

                                        container cos {
                                          when
                                            "../type = 'match-type-cos'" {
                                            description
                                              "../type = 'MATCH_TYPE_COS'";
                                          }
                                          description
                                            "Match CoS array";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container cos

                                        container cos-inr {
                                          when
                                            "../type = 'match-type-cos-inner'" {
                                            description
                                              "../type = 'MATCH_TYPE_COS_INNER'";
                                          }
                                          description
                                            "Match inner header CoS";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container cos-inr

                                        container dei {
                                          when
                                            "../type = 'match-type-dei'" {
                                            description
                                              "../type = 'MATCH_TYPE_DEI'";
                                          }
                                          description
                                            "Match DEI Bit";
                                          leaf bit-value {
                                            type uint32;
                                            description
                                              "Value of the DEI bit";
                                          }
                                        }  // container dei

                                        container dei-inr {
                                          when
                                            "../type = 'match-type-dei-inner'" {
                                            description
                                              "../type = 'MATCH_TYPE_DEI_INNER'";
                                          }
                                          description
                                            "Match inner DEI Bit";
                                          leaf bit-value {
                                            type uint32;
                                            description
                                              "Value of the DEI bit";
                                          }
                                        }  // container dei-inr

                                        container vlan {
                                          when
                                            "../type = 'match-type-vlan'" {
                                            description
                                              "../type = 'MATCH_TYPE_VLAN'";
                                          }
                                          description
                                            "Match VLAN array";
                                          list vlan-id-array {
                                            description
                                              "vlan id array";
                                            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";
                                            }
                                          }  // list 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";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          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
                                        }  // container src-mac

                                        container dst-mac {
                                          when
                                            "../type = 'match-type-dst-mac'" {
                                            description
                                              "../type = 'MATCH_TYPE_DST_MAC'";
                                          }
                                          description
                                            "Match Destination MAC address";
                                          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
                                        }  // container dst-mac

                                        container atm-clp {
                                          when
                                            "../type = 'match-type-atm-clp'" {
                                            description
                                              "../type = 'MATCH_TYPE_ATM_CLP'";
                                          }
                                          description
                                            "Match ATM CLP level";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "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";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container fr-de

                                        container ipv4-acl {
                                          when
                                            "../type = 'match-type-ipv4-acl'" {
                                            description
                                              "../type = 'MATCH_TYPE_IPV4_ACL'";
                                          }
                                          description
                                            "IPv4 Access-list";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container ipv4-acl

                                        container ipv6-acl {
                                          when
                                            "../type = 'match-type-ipv6-acl'" {
                                            description
                                              "../type = 'MATCH_TYPE_IPV6_ACL'";
                                          }
                                          description
                                            "IPv6 Access-list";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container ether-service-acl

                                        container avail-id {
                                          when
                                            "../type = 'match-type-avail-id'" {
                                            description
                                              "../type = 'MATCH_TYPE_AVAIL_ID'";
                                          }
                                          description
                                            "Available Identifiers";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container avail-id

                                        container media-type {
                                          when
                                            "../type = 'match-type-media'" {
                                            description
                                              "../type = 'MATCH_TYPE_MEDIA'";
                                          }
                                          description
                                            "Media Type";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container media-type

                                        container subs-protocol {
                                          when
                                            "../type = 'match-type-subs-protocol'" {
                                            description
                                              "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                          }
                                          description
                                            "Protocol";
                                          leaf-list uint8_array {
                                            type uint8;
                                            description
                                              "uint8 array";
                                          }
                                        }  // container subs-protocol

                                        container dnis {
                                          when
                                            "../type = 'match-type-dnis'" {
                                            description
                                              "../type = 'MATCH_TYPE_DNIS'";
                                          }
                                          description
                                            "DNIS";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container dnis

                                        container dnis-regex {
                                          when
                                            "../type = 'match-type-dnis-regexp'" {
                                            description
                                              "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                          }
                                          description
                                            "DNIS Regular Expression";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container dnis-regex

                                        container domain {
                                          when
                                            "../type = 'match-type-domain'" {
                                            description
                                              "../type = 'MATCH_TYPE_DOMAIN'";
                                          }
                                          description
                                            "Domain Name";
                                          list domain-array {
                                            description
                                              "domain array";
                                            leaf domain-name {
                                              type string;
                                              description
                                                "domain name";
                                            }

                                            leaf format-name {
                                              type string;
                                              description
                                                "format name";
                                            }
                                          }  // list domain-array
                                        }  // container domain

                                        container domain-regex {
                                          when
                                            "../type = 'match-type-domain-regexp'" {
                                            description
                                              "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                          }
                                          description
                                            "Domain Regular Expression";
                                          list domain-array {
                                            description
                                              "domain array";
                                            leaf domain-name {
                                              type string;
                                              description
                                                "domain name";
                                            }

                                            leaf format-name {
                                              type string;
                                              description
                                                "format name";
                                            }
                                          }  // list domain-array
                                        }  // container domain-regex

                                        container nas-port {
                                          when
                                            "../type = 'match-type-nas-port'" {
                                            description
                                              "../type = 'MATCH_TYPE_NAS_PORT'";
                                          }
                                          description
                                            "NAS Port";
                                          list nas-port-array {
                                            description
                                              "nas port array";
                                            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";
                                            }
                                          }  // list nas-port-array
                                        }  // container nas-port

                                        container service-name {
                                          when
                                            "../type = 'match-type-service-name'" {
                                            description
                                              "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                          }
                                          description
                                            "Service Name";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          list ipv4-addr-array {
                                            description
                                              "ipv4 addr array";
                                            leaf prefix {
                                              type inet:ipv4-address;
                                              description
                                                "prefix";
                                            }

                                            leaf mask {
                                              type inet:ipv4-address;
                                              description
                                                "mask";
                                            }
                                          }  // list 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";
                                          list ipv4-addr-array {
                                            description
                                              "ipv4 addr array";
                                            leaf prefix {
                                              type inet:ipv4-address;
                                              description
                                                "prefix";
                                            }

                                            leaf mask {
                                              type inet:ipv4-address;
                                              description
                                                "mask";
                                            }
                                          }  // list 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";
                                          list ipv6-addr-array {
                                            description
                                              "ipv6 addr array";
                                            leaf prefix {
                                              type inet:ipv6-address;
                                              description
                                                "IPV6 prefix";
                                            }

                                            leaf mask {
                                              type uint32;
                                              description
                                                "IPV6 mask";
                                            }
                                          }  // list 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";
                                          list ipv6-addr-array {
                                            description
                                              "ipv6 addr array";
                                            leaf prefix {
                                              type inet:ipv6-address;
                                              description
                                                "IPV6 prefix";
                                            }

                                            leaf mask {
                                              type uint32;
                                              description
                                                "IPV6 mask";
                                            }
                                          }  // list 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";
                                          list mac-addr-array {
                                            description
                                              "mac addr array";
                                            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
                                          }  // list mac-addr-array
                                        }  // container src-addr-mac

                                        container timer {
                                          when
                                            "../type = 'match-type-timer'" {
                                            description
                                              "../type = 'MATCH_TYPE_TIMER'";
                                          }
                                          description
                                            "Timer";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container timer

                                        container timer-regexp {
                                          when
                                            "../type = 'match-type-timer-regexp'" {
                                            description
                                              "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                          }
                                          description
                                            "Timer Regular Expression";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container timer-regexp

                                        container tunnel-name {
                                          when
                                            "../type = 'match-type-tunnel-name'" {
                                            description
                                              "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                          }
                                          description
                                            "Tunnel Name";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container tunnel-name-regex

                                        container user-name {
                                          when
                                            "../type = 'match-type-user-name'" {
                                            description
                                              "../type = 'MATCH_TYPE_USERNAME'";
                                          }
                                          description
                                            "User Name";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container unauth-domain-regex

                                        container vendor-id {
                                          when
                                            "../type = 'match-type-vendor-id'" {
                                            description
                                              "../type = 'MATCH_TYPE_VENDOR_ID'";
                                          }
                                          description
                                            "Vendor ID";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container vendor-id-regex

                                        container access-interface {
                                          when
                                            "../type = 'match-type-access-interface'" {
                                            description
                                              "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                          }
                                          description
                                            "Access interface";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container access-interface

                                        container input-interface {
                                          when
                                            "../type = 'match-type-input-interface'" {
                                            description
                                              "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                          }
                                          description
                                            "Input interface";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container input-interface

                                        container ethertype {
                                          when
                                            "../type = 'match-type-ether-type'" {
                                            description
                                              "../type = 'MATCH_TYPE_ETHERTYPE'";
                                          }
                                          description
                                            "Ethernet type";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                          container flow-keys {
                                            description
                                              "flow keys";
                                            leaf keys {
                                              type yang:hex-string;
                                              description
                                                "keys";
                                            }

                                            leaf num {
                                              type uint8;
                                              description
                                                "num";
                                            }
                                          }  // 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)";
                                          }
                                        }  // 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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container circuit-id-regex

                                        container remote-id {
                                          when
                                            "../type = 'match-type-remote-id'" {
                                            description
                                              "../type = 'MATCH_TYPE_REMOTE_ID'";
                                          }
                                          description
                                            "Remote ID";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "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";
                                          leaf-list string-array {
                                            type string;
                                            description
                                              "string array";
                                          }
                                        }  // container remote-id-regex

                                        container src-port {
                                          when
                                            "../type = 'match-type-src-port'" {
                                            description
                                              "../type = 'MATCH_TYPE_SRC_PORT'";
                                          }
                                          description
                                            "Source port";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint16_rng_array
                                        }  // container src-port

                                        container dst-port {
                                          when
                                            "../type = 'match-type-dst-port'" {
                                            description
                                              "../type = 'MATCH_TYPE_DST_PORT'";
                                          }
                                          description
                                            "Destination port";
                                          list uint16_rng_array {
                                            description
                                              "uint16 rng array";
                                            leaf min {
                                              type uint16;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint16;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list 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";
                                        }
                                      }  // container match-data

                                      leaf flags {
                                        type uint32;
                                        description
                                          "Flags";
                                      }
                                    }  // list 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
                              }  // container clmp-p

                              container act-infop {
                                description
                                  "act infop";
                                list policy-action-info-st {
                                  description
                                    "policy action info st";
                                  container actp {
                                    description
                                      "actp";
                                    container mark {
                                      when
                                        "../type = 'policy-action-mark'" {
                                        description
                                          "../type = 'POLICY_ACTION_MARK'";
                                      }
                                      description
                                        "mark";
                                      list action-mark-info {
                                        description
                                          "action mark info";
                                        leaf type {
                                          type Mark-type-en;
                                          description
                                            "type";
                                        }

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

                                        leaf value {
                                          type uint16;
                                          description
                                            "value";
                                        }
                                      }  // list action-mark-info
                                    }  // container mark

                                    container mark2 {
                                      when
                                        "../type = 'policy-action-mark2'" {
                                        description
                                          "../type = 'POLICY_ACTION_MARK2'";
                                      }
                                      description
                                        "mark2";
                                      list action-mark2-info {
                                        description
                                          "action mark2 info";
                                        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";
                                        }
                                      }  // list action-mark2-info
                                    }  // container mark2

                                    container wred {
                                      when
                                        "../type = 'policy-action-wred'" {
                                        description
                                          "../type = 'POLICY_ACTION_WRED'";
                                      }
                                      description
                                        "wred";
                                      list action-wred-info {
                                        description
                                          "action wred info";
                                        container match-ranges {
                                          description
                                            "match ranges";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint8_rng_array
                                        }  // container match-ranges

                                        container min-threshold {
                                          description
                                            "min threshold";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container min-threshold

                                        container max-threshold {
                                          description
                                            "max threshold";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // 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";
                                        }
                                      }  // list action-wred-info
                                    }  // container wred

                                    container encap {
                                      when
                                        "../type = 'policy-action-encap-seq'" {
                                        description
                                          "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                      }
                                      description
                                        "encap";
                                      leaf seq {
                                        type uint8;
                                        description
                                          "seq";
                                      }
                                    }  // container encap

                                    container prio {
                                      when
                                        "../type = 'policy-action-priority'" {
                                        description
                                          "../type = 'POLICY_ACTION_PRIORITY'";
                                      }
                                      description
                                        "prio";
                                      leaf prio-lvl {
                                        type uint32;
                                        description
                                          "prio lvl";
                                      }
                                    }  // container prio

                                    container bwrem {
                                      when
                                        "../type = 'policy-action-bw-remaining'" {
                                        description
                                          "../type = 'POLICY_ACTION_BW_REMAINING'";
                                      }
                                      description
                                        "bwrem";
                                      container bwrem {
                                        description
                                          "bwrem";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container bwrem
                                    }  // container bwrem

                                    container min-bw {
                                      when
                                        "../type = 'policy-action-min-bw'" {
                                        description
                                          "../type = 'POLICY_ACTION_MIN_BW'";
                                      }
                                      description
                                        "min bw";
                                      container bw {
                                        description
                                          "bw";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container bw
                                    }  // container min-bw

                                    container authen-aaa {
                                      when
                                        "../type = 'policy-action-authenticate-aaa'" {
                                        description
                                          "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                      }
                                      description
                                        "authen aaa";
                                      leaf aaa-list-name {
                                        type string;
                                        description
                                          "aaa list name";
                                      }

                                      leaf authen-password {
                                        type string;
                                        description
                                          "authen password";
                                      }
                                    }  // container authen-aaa

                                    container collect-id {
                                      when
                                        "../type = 'policy-action-collect-id'" {
                                        description
                                          "../type = 'POLICY_ACTION_COLLECT_ID'";
                                      }
                                      description
                                        "collect id";
                                      leaf id {
                                        type Identifier-en;
                                        description
                                          "id";
                                      }

                                      leaf aaa-list-name {
                                        type string;
                                        description
                                          "aaa list name";
                                      }
                                    }  // container collect-id

                                    container decode-id {
                                      when
                                        "../type = 'policy-action-decode-identifier'" {
                                        description
                                          "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                      }
                                      description
                                        "decode id";
                                      leaf id {
                                        type Decode-identifier-en;
                                        description
                                          "id";
                                      }

                                      leaf format-name {
                                        type string;
                                        description
                                          "format name";
                                      }
                                    }  // container decode-id

                                    container set-timer {
                                      when
                                        "../type = 'policy-action-set-timer'" {
                                        description
                                          "../type = 'POLICY_ACTION_SET_TIMER'";
                                      }
                                      description
                                        "set timer";
                                      leaf timer-name {
                                        type string;
                                        description
                                          "timer name";
                                      }

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

                                      leaf absolute-time {
                                        type string;
                                        description
                                          "absolute time";
                                      }
                                    }  // container set-timer

                                    container stop-timer {
                                      when
                                        "../type = 'policy-action-stop-timer'" {
                                        description
                                          "../type = 'POLICY_ACTION_STOP_TIMER'";
                                      }
                                      description
                                        "stop timer";
                                      leaf timer-name {
                                        type string;
                                        description
                                          "timer name";
                                      }
                                    }  // 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";
                                      leaf aaa-list-name {
                                        type string;
                                        description
                                          "aaa list name";
                                      }

                                      leaf secs {
                                        type uint32;
                                        description
                                          "secs";
                                      }
                                    }  // container acct-aaa-list

                                    container query-ancp {
                                      when
                                        "../type = 'policy-action-query-ancp'" {
                                        description
                                          "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                      }
                                      description
                                        "query ancp";
                                      leaf enable {
                                        type boolean;
                                        description
                                          "enable";
                                      }
                                    }  // container query-ancp

                                    container prepaid-cfg {
                                      when
                                        "../type = 'policy-action-prepaid-config'" {
                                        description
                                          "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                      }
                                      description
                                        "prepaid cfg";
                                      leaf prepaid-config-profile-name {
                                        type string;
                                        description
                                          "prepaid config profile name";
                                      }
                                    }  // container prepaid-cfg

                                    container timeout-idle {
                                      when
                                        "../type = 'policy-action-timeout-idle'" {
                                        description
                                          "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                      }
                                      description
                                        "timeout idle";
                                      leaf secs {
                                        type uint32;
                                        description
                                          "secs";
                                      }
                                    }  // container timeout-idle

                                    container proxy-aaa {
                                      when
                                        "../type = 'policy-action-proxy-aaa'" {
                                        description
                                          "../type = 'POLICY_ACTION_PROXY_AAA'";
                                      }
                                      description
                                        "proxy aaa";
                                      leaf aaa-list-name {
                                        type string;
                                        description
                                          "aaa list name";
                                      }
                                    }  // container proxy-aaa

                                    container act-template {
                                      when
                                        "../type = 'policy-action-template-activate'" {
                                        description
                                          "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                      }
                                      description
                                        "act template";
                                      leaf template-name {
                                        type string;
                                        description
                                          "template name";
                                      }

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

                                      leaf flags {
                                        type uint32;
                                        description
                                          "flags";
                                      }
                                    }  // container act-template

                                    container deact-template {
                                      when
                                        "../type = 'policy-action-template-deactivate'" {
                                        description
                                          "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                      }
                                      description
                                        "deact template";
                                      leaf template-name {
                                        type string;
                                        description
                                          "template name";
                                      }

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

                                      leaf flags {
                                        type uint32;
                                        description
                                          "flags";
                                      }
                                    }  // container deact-template

                                    container qlimit {
                                      when
                                        "../type = 'policy-action-q-limit'" {
                                        description
                                          "../type = 'POLICY_ACTION_Q_LIMIT'";
                                      }
                                      description
                                        "qlimit";
                                      list action-qlimit-info-array {
                                        description
                                          "action qlimit info array";
                                        container qlim {
                                          description
                                            "qlim";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container qlim

                                        container atmclp-qlim {
                                          description
                                            "atmclp qlim";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container atmclp-qlim

                                        container match-values {
                                          description
                                            "match values";
                                          list uint8_rng_array {
                                            description
                                              "uint8 rng array";
                                            leaf min {
                                              type uint8;
                                              description
                                                "Lower limit of the range";
                                            }

                                            leaf max {
                                              type uint8;
                                              description
                                                "Upper limit of the range";
                                            }
                                          }  // list uint8_rng_array
                                        }  // container match-values

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

                                        leaf qlimit-flags {
                                          type uint32;
                                          description
                                            "qlimit flags";
                                        }
                                      }  // list 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";
                                      leaf action {
                                        type Acct-en;
                                        description
                                          "action";
                                      }

                                      leaf aaa-list-name {
                                        type string;
                                        description
                                          "aaa list name";
                                      }
                                    }  // container accounting-event-aaa

                                    container authorize-id {
                                      when
                                        "../type = 'policy-action-authorize-id'" {
                                        description
                                          "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                      }
                                      description
                                        "authorize id";
                                      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";
                                      }
                                    }  // container authorize-id

                                    container afm-react {
                                      when
                                        "../type = 'policy-action-afmon-react'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_REACT'";
                                      }
                                      description
                                        "afm react";
                                      list action-afmon-react-info {
                                        description
                                          "action afmon react info";
                                        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";
                                        }
                                      }  // list action-afmon-react-info
                                    }  // container afm-react

                                    container httpr {
                                      when
                                        "../type = 'policy-action-httpr'" {
                                        description
                                          "../type = 'POLICY_ACTION_HTTPR'";
                                      }
                                      description
                                        "httpr";
                                      leaf redirect-url {
                                        type string;
                                        description
                                          "redirect url";
                                      }
                                    }  // container httpr

                                    container punt {
                                      when
                                        "../type = 'policy-action-punt'" {
                                        description
                                          "../type = 'POLICY_ACTION_PUNT'";
                                      }
                                      description
                                        "punt";
                                      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";
                                      }
                                    }  // container punt

                                    container copy {
                                      when
                                        "../type = 'policy-action-copy'" {
                                        description
                                          "../type = 'POLICY_ACTION_COPY'";
                                      }
                                      description
                                        "copy";
                                      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";
                                      }
                                    }  // container copy

                                    container sfrag {
                                      when
                                        "../type = 'policy-action-sfrag'" {
                                        description
                                          "../type = 'POLICY_ACTION_SFRAG'";
                                      }
                                      description
                                        "sfrag";
                                      leaf name {
                                        type string;
                                        description
                                          "Service Fragment Name";
                                      }
                                    }  // container sfrag

                                    container redirect {
                                      when
                                        "../type = 'policy-action-redirect'" {
                                        description
                                          "../type = 'POLICY_ACTION_REDIRECT'";
                                      }
                                      description
                                        "redirect";
                                      leaf value {
                                        type uint32;
                                        description
                                          "value";
                                      }

                                      leaf type {
                                        type Redirect-type-e;
                                        description
                                          "type";
                                      }
                                    }  // container redirect

                                    container out-intf {
                                      when
                                        "../type = 'policy-action-output-interface'" {
                                        description
                                          "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                      }
                                      description
                                        "out intf";
                                      leaf out-ifname {
                                        type string;
                                        description
                                          "output interface name";
                                      }
                                    }  // container out-intf

                                    container serv-func {
                                      when
                                        "../type = 'policy-action-service-function-path'" {
                                        description
                                          "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                      }
                                      description
                                        "serv func";
                                      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";
                                      }
                                    }  // 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";
                                      list action-police-info-st {
                                        description
                                          "action police info array";
                                        container rate {
                                          description
                                            "rate";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container rate

                                        container burst {
                                          description
                                            "burst";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container burst

                                        container peak-rate {
                                          description
                                            "peak rate";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container peak-rate

                                        container peak-burst {
                                          description
                                            "peak burst";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container peak-burst

                                        container cdvt {
                                          description
                                            "cdvt";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container cdvt

                                        container conform-actns {
                                          description
                                            "conform actns";
                                          list police-action-array {
                                            description
                                              "police action array";
                                            container mark {
                                              when
                                                "../type = 'police-action-mark'" {
                                                description
                                                  "../type = 'POLICE_ACTION_MARK'";
                                              }
                                              description
                                                "mark";
                                              leaf type {
                                                type Mark-type-en;
                                                description
                                                  "type";
                                              }

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

                                              leaf value {
                                                type uint16;
                                                description
                                                  "value";
                                              }
                                            }  // container mark

                                            leaf type {
                                              type Police-action-type-en;
                                              description
                                                "type";
                                            }
                                          }  // list police-action-array
                                        }  // container conform-actns

                                        container exceed-actns {
                                          description
                                            "exceed actns";
                                          list police-action-array {
                                            description
                                              "police action array";
                                            container mark {
                                              when
                                                "../type = 'police-action-mark'" {
                                                description
                                                  "../type = 'POLICE_ACTION_MARK'";
                                              }
                                              description
                                                "mark";
                                              leaf type {
                                                type Mark-type-en;
                                                description
                                                  "type";
                                              }

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

                                              leaf value {
                                                type uint16;
                                                description
                                                  "value";
                                              }
                                            }  // container mark

                                            leaf type {
                                              type Police-action-type-en;
                                              description
                                                "type";
                                            }
                                          }  // list police-action-array
                                        }  // container exceed-actns

                                        container violate-actns {
                                          description
                                            "violate actns";
                                          list police-action-array {
                                            description
                                              "police action array";
                                            container mark {
                                              when
                                                "../type = 'police-action-mark'" {
                                                description
                                                  "../type = 'POLICE_ACTION_MARK'";
                                              }
                                              description
                                                "mark";
                                              leaf type {
                                                type Mark-type-en;
                                                description
                                                  "type";
                                              }

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

                                              leaf value {
                                                type uint16;
                                                description
                                                  "value";
                                              }
                                            }  // container mark

                                            leaf type {
                                              type Police-action-type-en;
                                              description
                                                "type";
                                            }
                                          }  // list police-action-array
                                        }  // container violate-actns

                                        container confclass-p {
                                          description
                                            "confclass p";
                                          list class-map-bg {
                                            description
                                              "class map bg";
                                            container match-infop {
                                              description
                                                "Pointer to the first Match info";
                                              list class-match-info-st {
                                                description
                                                  "class match info st";
                                                container match-data {
                                                  description
                                                    "Match criteria";
                                                  container ipv4-dscp {
                                                    when
                                                      "../type = 'match-type-ipv4-dscp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                    }
                                                    description
                                                      "IPv4 DSCP";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container ipv4-dscp

                                                  container ipv6-dscp {
                                                    when
                                                      "../type = 'match-type-ipv6-dscp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                    }
                                                    description
                                                      "IPv6 DSCP";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container ipv6-dscp

                                                  container dscp {
                                                    when
                                                      "../type = 'match-type-dscp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DSCP'";
                                                    }
                                                    description
                                                      "Match DSCP range array";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container dscp

                                                  container ipv4-prec {
                                                    when
                                                      "../type = 'match-type-ipv4-prec'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                    }
                                                    description
                                                      "IPv4 Precedence";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container ipv4-prec

                                                  container ipv6-prec {
                                                    when
                                                      "../type = 'match-type-ipv6-prec'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                    }
                                                    description
                                                      "IPv6 Precedence";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container ipv6-prec

                                                  container prec {
                                                    when
                                                      "../type = 'match-type-prec'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_PREC'";
                                                    }
                                                    description
                                                      "Match Precedence array";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container prec

                                                  container discard-class {
                                                    when
                                                      "../type = 'match-type-disc-cls'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DISC_CLS'";
                                                    }
                                                    description
                                                      "Match Discard Class array";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container traffic-class

                                                  container proto {
                                                    when
                                                      "../type = 'match-type-proto'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_PROTO'";
                                                    }
                                                    description
                                                      "Match Protocol array";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    leaf value {
                                                      type uint16;
                                                      description
                                                        "Value of TCP flag";
                                                    }

                                                    leaf match-any {
                                                      type boolean;
                                                      description
                                                        "Match any TCP flag bit";
                                                    }
                                                  }  // container tcp-flag

                                                  container icmpv4-type {
                                                    when
                                                      "../type = 'match-type-icmpv4-type'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                    }
                                                    description
                                                      "Match ipv4 icmp type";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    list uint32_rng_array {
                                                      description
                                                        "uint32 rng array";
                                                      leaf min {
                                                        type uint32;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint32;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint32_rng_array
                                                  }  // container mpls-top-label

                                                  container cos {
                                                    when
                                                      "../type = 'match-type-cos'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_COS'";
                                                    }
                                                    description
                                                      "Match CoS array";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container cos

                                                  container cos-inr {
                                                    when
                                                      "../type = 'match-type-cos-inner'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_COS_INNER'";
                                                    }
                                                    description
                                                      "Match inner header CoS";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container cos-inr

                                                  container dei {
                                                    when
                                                      "../type = 'match-type-dei'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DEI'";
                                                    }
                                                    description
                                                      "Match DEI Bit";
                                                    leaf bit-value {
                                                      type uint32;
                                                      description
                                                        "Value of the DEI bit";
                                                    }
                                                  }  // container dei

                                                  container dei-inr {
                                                    when
                                                      "../type = 'match-type-dei-inner'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DEI_INNER'";
                                                    }
                                                    description
                                                      "Match inner DEI Bit";
                                                    leaf bit-value {
                                                      type uint32;
                                                      description
                                                        "Value of the DEI bit";
                                                    }
                                                  }  // container dei-inr

                                                  container vlan {
                                                    when
                                                      "../type = 'match-type-vlan'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_VLAN'";
                                                    }
                                                    description
                                                      "Match VLAN array";
                                                    list vlan-id-array {
                                                      description
                                                        "vlan id array";
                                                      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";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    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
                                                  }  // container src-mac

                                                  container dst-mac {
                                                    when
                                                      "../type = 'match-type-dst-mac'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DST_MAC'";
                                                    }
                                                    description
                                                      "Match Destination MAC address";
                                                    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
                                                  }  // container dst-mac

                                                  container atm-clp {
                                                    when
                                                      "../type = 'match-type-atm-clp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ATM_CLP'";
                                                    }
                                                    description
                                                      "Match ATM CLP level";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container fr-de

                                                  container ipv4-acl {
                                                    when
                                                      "../type = 'match-type-ipv4-acl'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                    }
                                                    description
                                                      "IPv4 Access-list";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container ipv4-acl

                                                  container ipv6-acl {
                                                    when
                                                      "../type = 'match-type-ipv6-acl'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                    }
                                                    description
                                                      "IPv6 Access-list";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container ether-service-acl

                                                  container avail-id {
                                                    when
                                                      "../type = 'match-type-avail-id'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                    }
                                                    description
                                                      "Available Identifiers";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container avail-id

                                                  container media-type {
                                                    when
                                                      "../type = 'match-type-media'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_MEDIA'";
                                                    }
                                                    description
                                                      "Media Type";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container media-type

                                                  container subs-protocol {
                                                    when
                                                      "../type = 'match-type-subs-protocol'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                    }
                                                    description
                                                      "Protocol";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container subs-protocol

                                                  container dnis {
                                                    when
                                                      "../type = 'match-type-dnis'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DNIS'";
                                                    }
                                                    description
                                                      "DNIS";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container dnis

                                                  container dnis-regex {
                                                    when
                                                      "../type = 'match-type-dnis-regexp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                    }
                                                    description
                                                      "DNIS Regular Expression";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container dnis-regex

                                                  container domain {
                                                    when
                                                      "../type = 'match-type-domain'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DOMAIN'";
                                                    }
                                                    description
                                                      "Domain Name";
                                                    list domain-array {
                                                      description
                                                        "domain array";
                                                      leaf domain-name {
                                                        type string;
                                                        description
                                                          "domain name";
                                                      }

                                                      leaf format-name {
                                                        type string;
                                                        description
                                                          "format name";
                                                      }
                                                    }  // list domain-array
                                                  }  // container domain

                                                  container domain-regex {
                                                    when
                                                      "../type = 'match-type-domain-regexp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                    }
                                                    description
                                                      "Domain Regular Expression";
                                                    list domain-array {
                                                      description
                                                        "domain array";
                                                      leaf domain-name {
                                                        type string;
                                                        description
                                                          "domain name";
                                                      }

                                                      leaf format-name {
                                                        type string;
                                                        description
                                                          "format name";
                                                      }
                                                    }  // list domain-array
                                                  }  // container domain-regex

                                                  container nas-port {
                                                    when
                                                      "../type = 'match-type-nas-port'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_NAS_PORT'";
                                                    }
                                                    description
                                                      "NAS Port";
                                                    list nas-port-array {
                                                      description
                                                        "nas port array";
                                                      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";
                                                      }
                                                    }  // list nas-port-array
                                                  }  // container nas-port

                                                  container service-name {
                                                    when
                                                      "../type = 'match-type-service-name'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                    }
                                                    description
                                                      "Service Name";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    list ipv4-addr-array {
                                                      description
                                                        "ipv4 addr array";
                                                      leaf prefix {
                                                        type inet:ipv4-address;
                                                        description
                                                          "prefix";
                                                      }

                                                      leaf mask {
                                                        type inet:ipv4-address;
                                                        description
                                                          "mask";
                                                      }
                                                    }  // list 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";
                                                    list ipv4-addr-array {
                                                      description
                                                        "ipv4 addr array";
                                                      leaf prefix {
                                                        type inet:ipv4-address;
                                                        description
                                                          "prefix";
                                                      }

                                                      leaf mask {
                                                        type inet:ipv4-address;
                                                        description
                                                          "mask";
                                                      }
                                                    }  // list 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";
                                                    list ipv6-addr-array {
                                                      description
                                                        "ipv6 addr array";
                                                      leaf prefix {
                                                        type inet:ipv6-address;
                                                        description
                                                          "IPV6 prefix";
                                                      }

                                                      leaf mask {
                                                        type uint32;
                                                        description
                                                          "IPV6 mask";
                                                      }
                                                    }  // list 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";
                                                    list ipv6-addr-array {
                                                      description
                                                        "ipv6 addr array";
                                                      leaf prefix {
                                                        type inet:ipv6-address;
                                                        description
                                                          "IPV6 prefix";
                                                      }

                                                      leaf mask {
                                                        type uint32;
                                                        description
                                                          "IPV6 mask";
                                                      }
                                                    }  // list 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";
                                                    list mac-addr-array {
                                                      description
                                                        "mac addr array";
                                                      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
                                                    }  // list mac-addr-array
                                                  }  // container src-addr-mac

                                                  container timer {
                                                    when
                                                      "../type = 'match-type-timer'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_TIMER'";
                                                    }
                                                    description
                                                      "Timer";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container timer

                                                  container timer-regexp {
                                                    when
                                                      "../type = 'match-type-timer-regexp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                    }
                                                    description
                                                      "Timer Regular Expression";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container timer-regexp

                                                  container tunnel-name {
                                                    when
                                                      "../type = 'match-type-tunnel-name'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                    }
                                                    description
                                                      "Tunnel Name";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container tunnel-name-regex

                                                  container user-name {
                                                    when
                                                      "../type = 'match-type-user-name'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_USERNAME'";
                                                    }
                                                    description
                                                      "User Name";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container unauth-domain-regex

                                                  container vendor-id {
                                                    when
                                                      "../type = 'match-type-vendor-id'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                    }
                                                    description
                                                      "Vendor ID";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container vendor-id-regex

                                                  container access-interface {
                                                    when
                                                      "../type = 'match-type-access-interface'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                    }
                                                    description
                                                      "Access interface";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container access-interface

                                                  container input-interface {
                                                    when
                                                      "../type = 'match-type-input-interface'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                    }
                                                    description
                                                      "Input interface";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container input-interface

                                                  container ethertype {
                                                    when
                                                      "../type = 'match-type-ether-type'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                    }
                                                    description
                                                      "Ethernet type";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    container flow-keys {
                                                      description
                                                        "flow keys";
                                                      leaf keys {
                                                        type yang:hex-string;
                                                        description
                                                          "keys";
                                                      }

                                                      leaf num {
                                                        type uint8;
                                                        description
                                                          "num";
                                                      }
                                                    }  // 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)";
                                                    }
                                                  }  // 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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container circuit-id-regex

                                                  container remote-id {
                                                    when
                                                      "../type = 'match-type-remote-id'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                    }
                                                    description
                                                      "Remote ID";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container remote-id-regex

                                                  container src-port {
                                                    when
                                                      "../type = 'match-type-src-port'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_SRC_PORT'";
                                                    }
                                                    description
                                                      "Source port";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint16_rng_array
                                                  }  // container src-port

                                                  container dst-port {
                                                    when
                                                      "../type = 'match-type-dst-port'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DST_PORT'";
                                                    }
                                                    description
                                                      "Destination port";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                  }
                                                }  // container match-data

                                                leaf flags {
                                                  type uint32;
                                                  description
                                                    "Flags";
                                                }
                                              }  // list 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
                                        }  // container confclass-p

                                        container excdclass-p {
                                          description
                                            "excdclass p";
                                          list class-map-bg {
                                            description
                                              "class map bg";
                                            container match-infop {
                                              description
                                                "Pointer to the first Match info";
                                              list class-match-info-st {
                                                description
                                                  "class match info st";
                                                container match-data {
                                                  description
                                                    "Match criteria";
                                                  container ipv4-dscp {
                                                    when
                                                      "../type = 'match-type-ipv4-dscp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                    }
                                                    description
                                                      "IPv4 DSCP";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container ipv4-dscp

                                                  container ipv6-dscp {
                                                    when
                                                      "../type = 'match-type-ipv6-dscp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                    }
                                                    description
                                                      "IPv6 DSCP";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container ipv6-dscp

                                                  container dscp {
                                                    when
                                                      "../type = 'match-type-dscp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DSCP'";
                                                    }
                                                    description
                                                      "Match DSCP range array";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container dscp

                                                  container ipv4-prec {
                                                    when
                                                      "../type = 'match-type-ipv4-prec'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                    }
                                                    description
                                                      "IPv4 Precedence";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container ipv4-prec

                                                  container ipv6-prec {
                                                    when
                                                      "../type = 'match-type-ipv6-prec'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                    }
                                                    description
                                                      "IPv6 Precedence";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container ipv6-prec

                                                  container prec {
                                                    when
                                                      "../type = 'match-type-prec'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_PREC'";
                                                    }
                                                    description
                                                      "Match Precedence array";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container prec

                                                  container discard-class {
                                                    when
                                                      "../type = 'match-type-disc-cls'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DISC_CLS'";
                                                    }
                                                    description
                                                      "Match Discard Class array";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint8_rng_array
                                                  }  // container traffic-class

                                                  container proto {
                                                    when
                                                      "../type = 'match-type-proto'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_PROTO'";
                                                    }
                                                    description
                                                      "Match Protocol array";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    leaf value {
                                                      type uint16;
                                                      description
                                                        "Value of TCP flag";
                                                    }

                                                    leaf match-any {
                                                      type boolean;
                                                      description
                                                        "Match any TCP flag bit";
                                                    }
                                                  }  // container tcp-flag

                                                  container icmpv4-type {
                                                    when
                                                      "../type = 'match-type-icmpv4-type'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                    }
                                                    description
                                                      "Match ipv4 icmp type";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint8_rng_array {
                                                      description
                                                        "uint8 rng array";
                                                      leaf min {
                                                        type uint8;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint8;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    list uint32_rng_array {
                                                      description
                                                        "uint32 rng array";
                                                      leaf min {
                                                        type uint32;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint32;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint32_rng_array
                                                  }  // container mpls-top-label

                                                  container cos {
                                                    when
                                                      "../type = 'match-type-cos'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_COS'";
                                                    }
                                                    description
                                                      "Match CoS array";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container cos

                                                  container cos-inr {
                                                    when
                                                      "../type = 'match-type-cos-inner'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_COS_INNER'";
                                                    }
                                                    description
                                                      "Match inner header CoS";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container cos-inr

                                                  container dei {
                                                    when
                                                      "../type = 'match-type-dei'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DEI'";
                                                    }
                                                    description
                                                      "Match DEI Bit";
                                                    leaf bit-value {
                                                      type uint32;
                                                      description
                                                        "Value of the DEI bit";
                                                    }
                                                  }  // container dei

                                                  container dei-inr {
                                                    when
                                                      "../type = 'match-type-dei-inner'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DEI_INNER'";
                                                    }
                                                    description
                                                      "Match inner DEI Bit";
                                                    leaf bit-value {
                                                      type uint32;
                                                      description
                                                        "Value of the DEI bit";
                                                    }
                                                  }  // container dei-inr

                                                  container vlan {
                                                    when
                                                      "../type = 'match-type-vlan'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_VLAN'";
                                                    }
                                                    description
                                                      "Match VLAN array";
                                                    list vlan-id-array {
                                                      description
                                                        "vlan id array";
                                                      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";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    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
                                                  }  // container src-mac

                                                  container dst-mac {
                                                    when
                                                      "../type = 'match-type-dst-mac'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DST_MAC'";
                                                    }
                                                    description
                                                      "Match Destination MAC address";
                                                    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
                                                  }  // container dst-mac

                                                  container atm-clp {
                                                    when
                                                      "../type = 'match-type-atm-clp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ATM_CLP'";
                                                    }
                                                    description
                                                      "Match ATM CLP level";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "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";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container fr-de

                                                  container ipv4-acl {
                                                    when
                                                      "../type = 'match-type-ipv4-acl'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                    }
                                                    description
                                                      "IPv4 Access-list";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container ipv4-acl

                                                  container ipv6-acl {
                                                    when
                                                      "../type = 'match-type-ipv6-acl'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                    }
                                                    description
                                                      "IPv6 Access-list";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container ether-service-acl

                                                  container avail-id {
                                                    when
                                                      "../type = 'match-type-avail-id'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                    }
                                                    description
                                                      "Available Identifiers";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container avail-id

                                                  container media-type {
                                                    when
                                                      "../type = 'match-type-media'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_MEDIA'";
                                                    }
                                                    description
                                                      "Media Type";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container media-type

                                                  container subs-protocol {
                                                    when
                                                      "../type = 'match-type-subs-protocol'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                    }
                                                    description
                                                      "Protocol";
                                                    leaf-list uint8_array {
                                                      type uint8;
                                                      description
                                                        "uint8 array";
                                                    }
                                                  }  // container subs-protocol

                                                  container dnis {
                                                    when
                                                      "../type = 'match-type-dnis'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DNIS'";
                                                    }
                                                    description
                                                      "DNIS";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container dnis

                                                  container dnis-regex {
                                                    when
                                                      "../type = 'match-type-dnis-regexp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                    }
                                                    description
                                                      "DNIS Regular Expression";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container dnis-regex

                                                  container domain {
                                                    when
                                                      "../type = 'match-type-domain'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DOMAIN'";
                                                    }
                                                    description
                                                      "Domain Name";
                                                    list domain-array {
                                                      description
                                                        "domain array";
                                                      leaf domain-name {
                                                        type string;
                                                        description
                                                          "domain name";
                                                      }

                                                      leaf format-name {
                                                        type string;
                                                        description
                                                          "format name";
                                                      }
                                                    }  // list domain-array
                                                  }  // container domain

                                                  container domain-regex {
                                                    when
                                                      "../type = 'match-type-domain-regexp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                    }
                                                    description
                                                      "Domain Regular Expression";
                                                    list domain-array {
                                                      description
                                                        "domain array";
                                                      leaf domain-name {
                                                        type string;
                                                        description
                                                          "domain name";
                                                      }

                                                      leaf format-name {
                                                        type string;
                                                        description
                                                          "format name";
                                                      }
                                                    }  // list domain-array
                                                  }  // container domain-regex

                                                  container nas-port {
                                                    when
                                                      "../type = 'match-type-nas-port'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_NAS_PORT'";
                                                    }
                                                    description
                                                      "NAS Port";
                                                    list nas-port-array {
                                                      description
                                                        "nas port array";
                                                      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";
                                                      }
                                                    }  // list nas-port-array
                                                  }  // container nas-port

                                                  container service-name {
                                                    when
                                                      "../type = 'match-type-service-name'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                    }
                                                    description
                                                      "Service Name";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    list ipv4-addr-array {
                                                      description
                                                        "ipv4 addr array";
                                                      leaf prefix {
                                                        type inet:ipv4-address;
                                                        description
                                                          "prefix";
                                                      }

                                                      leaf mask {
                                                        type inet:ipv4-address;
                                                        description
                                                          "mask";
                                                      }
                                                    }  // list 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";
                                                    list ipv4-addr-array {
                                                      description
                                                        "ipv4 addr array";
                                                      leaf prefix {
                                                        type inet:ipv4-address;
                                                        description
                                                          "prefix";
                                                      }

                                                      leaf mask {
                                                        type inet:ipv4-address;
                                                        description
                                                          "mask";
                                                      }
                                                    }  // list 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";
                                                    list ipv6-addr-array {
                                                      description
                                                        "ipv6 addr array";
                                                      leaf prefix {
                                                        type inet:ipv6-address;
                                                        description
                                                          "IPV6 prefix";
                                                      }

                                                      leaf mask {
                                                        type uint32;
                                                        description
                                                          "IPV6 mask";
                                                      }
                                                    }  // list 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";
                                                    list ipv6-addr-array {
                                                      description
                                                        "ipv6 addr array";
                                                      leaf prefix {
                                                        type inet:ipv6-address;
                                                        description
                                                          "IPV6 prefix";
                                                      }

                                                      leaf mask {
                                                        type uint32;
                                                        description
                                                          "IPV6 mask";
                                                      }
                                                    }  // list 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";
                                                    list mac-addr-array {
                                                      description
                                                        "mac addr array";
                                                      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
                                                    }  // list mac-addr-array
                                                  }  // container src-addr-mac

                                                  container timer {
                                                    when
                                                      "../type = 'match-type-timer'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_TIMER'";
                                                    }
                                                    description
                                                      "Timer";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container timer

                                                  container timer-regexp {
                                                    when
                                                      "../type = 'match-type-timer-regexp'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                    }
                                                    description
                                                      "Timer Regular Expression";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container timer-regexp

                                                  container tunnel-name {
                                                    when
                                                      "../type = 'match-type-tunnel-name'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                    }
                                                    description
                                                      "Tunnel Name";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container tunnel-name-regex

                                                  container user-name {
                                                    when
                                                      "../type = 'match-type-user-name'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_USERNAME'";
                                                    }
                                                    description
                                                      "User Name";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container unauth-domain-regex

                                                  container vendor-id {
                                                    when
                                                      "../type = 'match-type-vendor-id'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                    }
                                                    description
                                                      "Vendor ID";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container vendor-id-regex

                                                  container access-interface {
                                                    when
                                                      "../type = 'match-type-access-interface'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                    }
                                                    description
                                                      "Access interface";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container access-interface

                                                  container input-interface {
                                                    when
                                                      "../type = 'match-type-input-interface'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                    }
                                                    description
                                                      "Input interface";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container input-interface

                                                  container ethertype {
                                                    when
                                                      "../type = 'match-type-ether-type'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                    }
                                                    description
                                                      "Ethernet type";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                    container flow-keys {
                                                      description
                                                        "flow keys";
                                                      leaf keys {
                                                        type yang:hex-string;
                                                        description
                                                          "keys";
                                                      }

                                                      leaf num {
                                                        type uint8;
                                                        description
                                                          "num";
                                                      }
                                                    }  // 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)";
                                                    }
                                                  }  // 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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container circuit-id-regex

                                                  container remote-id {
                                                    when
                                                      "../type = 'match-type-remote-id'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                    }
                                                    description
                                                      "Remote ID";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "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";
                                                    leaf-list string-array {
                                                      type string;
                                                      description
                                                        "string array";
                                                    }
                                                  }  // container remote-id-regex

                                                  container src-port {
                                                    when
                                                      "../type = 'match-type-src-port'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_SRC_PORT'";
                                                    }
                                                    description
                                                      "Source port";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list uint16_rng_array
                                                  }  // container src-port

                                                  container dst-port {
                                                    when
                                                      "../type = 'match-type-dst-port'" {
                                                      description
                                                        "../type = 'MATCH_TYPE_DST_PORT'";
                                                    }
                                                    description
                                                      "Destination port";
                                                    list uint16_rng_array {
                                                      description
                                                        "uint16 rng array";
                                                      leaf min {
                                                        type uint16;
                                                        description
                                                          "Lower limit of the range";
                                                      }

                                                      leaf max {
                                                        type uint16;
                                                        description
                                                          "Upper limit of the range";
                                                      }
                                                    }  // list 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";
                                                  }
                                                }  // container match-data

                                                leaf flags {
                                                  type uint32;
                                                  description
                                                    "Flags";
                                                }
                                              }  // list 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
                                        }  // 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";
                                        }
                                      }  // list action-police-info-st
                                    }  // container police

                                    container shape {
                                      when
                                        "../type = 'policy-action-shape'" {
                                        description
                                          "../type = 'POLICY_ACTION_SHAPE'";
                                      }
                                      description
                                        "shape";
                                      list action-shape-info-st {
                                        description
                                          "action police info array";
                                        container bw {
                                          description
                                            "bw";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container bw

                                        container be {
                                          description
                                            "be";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container be
                                      }  // list action-shape-info-st
                                    }  // container shape

                                    container child-policy {
                                      when
                                        "../type = 'policy-action-serv-pol'" {
                                        description
                                          "../type = 'POLICY_ACTION_SERV_POL'";
                                      }
                                      description
                                        "child policy";
                                      list action-policy-info-st {
                                        description
                                          "child policy info";
                                        container info {
                                          when
                                            "../enc = 'policy-obj-enc-name'" {
                                            description
                                              "../enc = 'POLICY_OBJ_ENC_NAME'";
                                          }
                                          description
                                            "info";
                                          leaf name {
                                            type Policy-map-name;
                                            description
                                              "name";
                                          }

                                          leaf type {
                                            type Policy-map-type-en;
                                            description
                                              "type";
                                          }
                                        }  // container info

                                        container hd-info {
                                          when
                                            "../enc = 'policy-obj-enc-hdl'" {
                                            description
                                              "../enc = 'POLICY_OBJ_ENC_HDL'";
                                          }
                                          description
                                            "hd info";
                                          container data-hd {
                                            description
                                              "data hd";
                                            list policy-map-name-type {
                                              description
                                                "policy map type and name";
                                              leaf name {
                                                type Policy-map-name;
                                                description
                                                  "name";
                                              }

                                              leaf type {
                                                type Policy-map-type-en;
                                                description
                                                  "type";
                                              }
                                            }  // list policy-map-name-type
                                          }  // container data-hd
                                        }  // container hd-info

                                        leaf enc {
                                          type Policy-obj-enc-en;
                                          description
                                            "enc";
                                        }
                                      }  // list action-policy-info-st
                                    }  // container child-policy

                                    container cac {
                                      when
                                        "../type = 'policy-action-cac'" {
                                        description
                                          "../type = 'POLICY_ACTION_CAC'";
                                      }
                                      description
                                        "cac";
                                      list action-cac-info-st {
                                        description
                                          "action cac info st";
                                        container flow-rate {
                                          description
                                            "flow rate";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container flow-rate

                                        container rate {
                                          description
                                            "rate";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container rate

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

                                        leaf idle-timeout {
                                          type uint16;
                                          description
                                            "idle timeout";
                                        }
                                      }  // list action-cac-info-st
                                    }  // container cac

                                    container pfc {
                                      when
                                        "../type = 'policy-action-pfc'" {
                                        description
                                          "../type = 'POLICY_ACTION_PFC'";
                                      }
                                      description
                                        "pfc";
                                      list action-pfc-info-st {
                                        description
                                          "action pfc info st";
                                        container buffer-size {
                                          description
                                            "buffer size";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container buffer-size

                                        container pause-threshold {
                                          description
                                            "pause threshold";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container pause-threshold

                                        container resume-threshold {
                                          description
                                            "resume threshold";
                                          leaf value {
                                            type uint32;
                                            description
                                              "value";
                                          }

                                          leaf unit {
                                            type Policy-param-unit-type;
                                            description
                                              "unit";
                                          }
                                        }  // container resume-threshold

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

                                        leaf buffer-size-flag {
                                          type uint32;
                                          description
                                            "buffer size flag";
                                        }
                                      }  // list action-pfc-info-st
                                    }  // container pfc

                                    container flow-parm {
                                      when
                                        "../type = 'policy-action-afmon-flow-parm'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                      }
                                      description
                                        "flow parm";
                                      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";
                                      }
                                    }  // container flow-parm

                                    container ipcbr {
                                      when
                                        "../type = 'policy-action-afmon-ipcbr-metric'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                      }
                                      description
                                        "ipcbr";
                                      container ip-bit-rate {
                                        description
                                          "data rate in bps";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container ip-bit-rate

                                      container media-bit-rate {
                                        description
                                          "media data rate in bps";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // 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";
                                      }
                                    }  // container ipcbr

                                    container rtp {
                                      when
                                        "../type = 'policy-action-afmon-rtp-metric'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                      }
                                      description
                                        "rtp";
                                      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";
                                        leaf pt {
                                          type uint32;
                                          description
                                            "pt";
                                        }

                                        leaf frequency {
                                          type uint32;
                                          description
                                            "frequency";
                                        }
                                      }  // list clock-rate
                                    }  // container rtp

                                    container rtp-mmr {
                                      when
                                        "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                      }
                                      description
                                        "rtp mmr";
                                      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";
                                        leaf pt {
                                          type uint32;
                                          description
                                            "pt";
                                        }

                                        leaf frequency {
                                          type uint32;
                                          description
                                            "frequency";
                                        }
                                      }  // list clock-rate
                                    }  // 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";
                                      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";
                                        leaf pt {
                                          type uint32;
                                          description
                                            "pt";
                                        }

                                        leaf frequency {
                                          type uint32;
                                          description
                                            "frequency";
                                        }
                                      }  // list clock-rate
                                    }  // 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";
                                      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";
                                        leaf pt {
                                          type uint32;
                                          description
                                            "pt";
                                        }

                                        leaf frequency {
                                          type uint32;
                                          description
                                            "frequency";
                                        }
                                      }  // list clock-rate
                                    }  // container rtp-voice

                                    container mdi {
                                      when
                                        "../type = 'policy-action-afmon-mdi-metric'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                      }
                                      description
                                        "mdi";
                                      container ip-bit-rate {
                                        description
                                          "data rate in bps";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // 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";
                                      }
                                    }  // container mdi

                                    container mdi-rtp {
                                      when
                                        "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                      }
                                      description
                                        "mdi rtp";
                                      container ip-bit-rate {
                                        description
                                          "data rate in bps";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // 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";
                                      }
                                    }  // container mdi-rtp

                                    container fmm {
                                      when
                                        "../type = 'policy-action-afmon-fmm'" {
                                        description
                                          "../type = 'POLICY_ACTION_AFMON_FMM'";
                                      }
                                      description
                                        "fmm";
                                      leaf fmm-name {
                                        type string {
                                          length
                                            "0..33";
                                        }
                                        description
                                          "flow monitor name";
                                      }
                                    }  // container fmm

                                    container pbf {
                                      when
                                        "../type = 'policy-action-pbr-next-hop'" {
                                        description
                                          "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                      }
                                      description
                                        "pbf";
                                      list action-pbf-info-array {
                                        description
                                          "action pbf info array";
                                        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";
                                        }
                                      }  // list action-pbf-info-array
                                    }  // container pbf

                                    container ipv4-nh {
                                      when
                                        "../type = 'policy-action-ipv4-nh'" {
                                        description
                                          "../type = 'POLICY_ACTION_IPV4_NH'";
                                      }
                                      description
                                        "ipv4 nh";
                                      list action-ipv4-nh-info-array {
                                        description
                                          "action ipv4 nh info array";
                                        leaf ipv4-nh-addr {
                                          type inet:ipv4-address;
                                          description
                                            "nh addr";
                                        }

                                        leaf vrf-name {
                                          type string;
                                          description
                                            "Vrf name";
                                        }
                                      }  // list 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";
                                      list action-ipv6-nh-info-array {
                                        description
                                          "action ipv6 nh info array";
                                        leaf ipv6-nh-addr {
                                          type inet:ipv6-address;
                                          description
                                            "IPV6 Address";
                                        }

                                        leaf vrf-name {
                                          type string;
                                          description
                                            "Vrf name";
                                        }
                                      }  // list 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";
                                    }
                                  }  // container actp

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

                                  leaf flags {
                                    type uint16;
                                    description
                                      "flags";
                                  }
                                }  // list policy-action-info-st
                              }  // container act-infop

                              container nlri-infop {
                                description
                                  "nlri info pointer";
                                container nlri {
                                  description
                                    "nlri value";
                                  leaf-list uint8_array {
                                    type uint8;
                                    description
                                      "uint8 array";
                                  }
                                }  // container nlri
                              }  // 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
                          }  // 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
                      }  // 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
                  }  // 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";
                  }

                  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";
                    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";
                    }
                  }  // list reference

                  list objects {
                    description
                      "Each object details";
                    leaf object-name {
                      type string {
                        length "0..64";
                      }
                      description
                        "Name of object (Policymap/Classmap)";
                    }
                  }  // list objects

                  list class-map-reference {
                    description
                      "Each Classmapdetails";
                    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";
                      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";
                      }
                    }  // list policy-map-reference
                  }  // list class-map-reference
                }  // 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";
                  }

                  list policy-map-bg {
                    description
                      "policy map bg";
                    container pmap-var-list {
                      description
                        "contains variable argument data";
                      list pmap-var-list-arr {
                        description
                          "pmap var list arr";
                        container val {
                          description "val";
                          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";
                          }
                        }  // container val

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

                        leaf id {
                          type uint32;
                          description "id";
                        }
                      }  // list pmap-var-list-arr
                    }  // container pmap-var-list

                    container event-infop {
                      description
                        "event infop";
                      list policy-event-info-bg {
                        description
                          "policy event info bg";
                        container class-infop {
                          description
                            "class infop";
                          list policy-class-info-bg {
                            description
                              "policy class info bg";
                            container clmp-p {
                              description
                                "clmp p";
                              list class-map-bg {
                                description
                                  "class map bg";
                                container match-infop {
                                  description
                                    "Pointer to the first Match info";
                                  list class-match-info-st {
                                    description
                                      "class match info st";
                                    container match-data {
                                      description
                                        "Match criteria";
                                      container ipv4-dscp {
                                        when
                                          "../type = 'match-type-ipv4-dscp'" {
                                          description
                                            "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                        }
                                        description
                                          "IPv4 DSCP";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint8_rng_array
                                      }  // container ipv4-dscp

                                      container ipv6-dscp {
                                        when
                                          "../type = 'match-type-ipv6-dscp'" {
                                          description
                                            "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                        }
                                        description
                                          "IPv6 DSCP";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint8_rng_array
                                      }  // container ipv6-dscp

                                      container dscp {
                                        when
                                          "../type = 'match-type-dscp'" {
                                          description
                                            "../type = 'MATCH_TYPE_DSCP'";
                                        }
                                        description
                                          "Match DSCP range array";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint8_rng_array
                                      }  // container dscp

                                      container ipv4-prec {
                                        when
                                          "../type = 'match-type-ipv4-prec'" {
                                          description
                                            "../type = 'MATCH_TYPE_IPV4_PREC'";
                                        }
                                        description
                                          "IPv4 Precedence";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container ipv4-prec

                                      container ipv6-prec {
                                        when
                                          "../type = 'match-type-ipv6-prec'" {
                                          description
                                            "../type = 'MATCH_TYPE_IPV6_PREC'";
                                        }
                                        description
                                          "IPv6 Precedence";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container ipv6-prec

                                      container prec {
                                        when
                                          "../type = 'match-type-prec'" {
                                          description
                                            "../type = 'MATCH_TYPE_PREC'";
                                        }
                                        description
                                          "Match Precedence array";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container prec

                                      container discard-class {
                                        when
                                          "../type = 'match-type-disc-cls'" {
                                          description
                                            "../type = 'MATCH_TYPE_DISC_CLS'";
                                        }
                                        description
                                          "Match Discard Class array";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "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";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint8_rng_array
                                      }  // container traffic-class

                                      container proto {
                                        when
                                          "../type = 'match-type-proto'" {
                                          description
                                            "../type = 'MATCH_TYPE_PROTO'";
                                        }
                                        description
                                          "Match Protocol array";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        leaf value {
                                          type uint16;
                                          description
                                            "Value of TCP flag";
                                        }

                                        leaf match-any {
                                          type boolean;
                                          description
                                            "Match any TCP flag bit";
                                        }
                                      }  // container tcp-flag

                                      container icmpv4-type {
                                        when
                                          "../type = 'match-type-icmpv4-type'" {
                                          description
                                            "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                        }
                                        description
                                          "Match ipv4 icmp type";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "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";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        list uint32_rng_array {
                                          description
                                            "uint32 rng array";
                                          leaf min {
                                            type uint32;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint32;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint32_rng_array
                                      }  // container mpls-top-label

                                      container cos {
                                        when
                                          "../type = 'match-type-cos'" {
                                          description
                                            "../type = 'MATCH_TYPE_COS'";
                                        }
                                        description
                                          "Match CoS array";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container cos

                                      container cos-inr {
                                        when
                                          "../type = 'match-type-cos-inner'" {
                                          description
                                            "../type = 'MATCH_TYPE_COS_INNER'";
                                        }
                                        description
                                          "Match inner header CoS";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container cos-inr

                                      container dei {
                                        when
                                          "../type = 'match-type-dei'" {
                                          description
                                            "../type = 'MATCH_TYPE_DEI'";
                                        }
                                        description
                                          "Match DEI Bit";
                                        leaf bit-value {
                                          type uint32;
                                          description
                                            "Value of the DEI bit";
                                        }
                                      }  // container dei

                                      container dei-inr {
                                        when
                                          "../type = 'match-type-dei-inner'" {
                                          description
                                            "../type = 'MATCH_TYPE_DEI_INNER'";
                                        }
                                        description
                                          "Match inner DEI Bit";
                                        leaf bit-value {
                                          type uint32;
                                          description
                                            "Value of the DEI bit";
                                        }
                                      }  // container dei-inr

                                      container vlan {
                                        when
                                          "../type = 'match-type-vlan'" {
                                          description
                                            "../type = 'MATCH_TYPE_VLAN'";
                                        }
                                        description
                                          "Match VLAN array";
                                        list vlan-id-array {
                                          description
                                            "vlan id array";
                                          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";
                                          }
                                        }  // list 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";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        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
                                      }  // container src-mac

                                      container dst-mac {
                                        when
                                          "../type = 'match-type-dst-mac'" {
                                          description
                                            "../type = 'MATCH_TYPE_DST_MAC'";
                                        }
                                        description
                                          "Match Destination MAC address";
                                        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
                                      }  // container dst-mac

                                      container atm-clp {
                                        when
                                          "../type = 'match-type-atm-clp'" {
                                          description
                                            "../type = 'MATCH_TYPE_ATM_CLP'";
                                        }
                                        description
                                          "Match ATM CLP level";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "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";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container fr-de

                                      container ipv4-acl {
                                        when
                                          "../type = 'match-type-ipv4-acl'" {
                                          description
                                            "../type = 'MATCH_TYPE_IPV4_ACL'";
                                        }
                                        description
                                          "IPv4 Access-list";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container ipv4-acl

                                      container ipv6-acl {
                                        when
                                          "../type = 'match-type-ipv6-acl'" {
                                          description
                                            "../type = 'MATCH_TYPE_IPV6_ACL'";
                                        }
                                        description
                                          "IPv6 Access-list";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container ether-service-acl

                                      container avail-id {
                                        when
                                          "../type = 'match-type-avail-id'" {
                                          description
                                            "../type = 'MATCH_TYPE_AVAIL_ID'";
                                        }
                                        description
                                          "Available Identifiers";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container avail-id

                                      container media-type {
                                        when
                                          "../type = 'match-type-media'" {
                                          description
                                            "../type = 'MATCH_TYPE_MEDIA'";
                                        }
                                        description
                                          "Media Type";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container media-type

                                      container subs-protocol {
                                        when
                                          "../type = 'match-type-subs-protocol'" {
                                          description
                                            "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                        }
                                        description
                                          "Protocol";
                                        leaf-list uint8_array {
                                          type uint8;
                                          description
                                            "uint8 array";
                                        }
                                      }  // container subs-protocol

                                      container dnis {
                                        when
                                          "../type = 'match-type-dnis'" {
                                          description
                                            "../type = 'MATCH_TYPE_DNIS'";
                                        }
                                        description
                                          "DNIS";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container dnis

                                      container dnis-regex {
                                        when
                                          "../type = 'match-type-dnis-regexp'" {
                                          description
                                            "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                        }
                                        description
                                          "DNIS Regular Expression";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container dnis-regex

                                      container domain {
                                        when
                                          "../type = 'match-type-domain'" {
                                          description
                                            "../type = 'MATCH_TYPE_DOMAIN'";
                                        }
                                        description
                                          "Domain Name";
                                        list domain-array {
                                          description
                                            "domain array";
                                          leaf domain-name {
                                            type string;
                                            description
                                              "domain name";
                                          }

                                          leaf format-name {
                                            type string;
                                            description
                                              "format name";
                                          }
                                        }  // list domain-array
                                      }  // container domain

                                      container domain-regex {
                                        when
                                          "../type = 'match-type-domain-regexp'" {
                                          description
                                            "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                        }
                                        description
                                          "Domain Regular Expression";
                                        list domain-array {
                                          description
                                            "domain array";
                                          leaf domain-name {
                                            type string;
                                            description
                                              "domain name";
                                          }

                                          leaf format-name {
                                            type string;
                                            description
                                              "format name";
                                          }
                                        }  // list domain-array
                                      }  // container domain-regex

                                      container nas-port {
                                        when
                                          "../type = 'match-type-nas-port'" {
                                          description
                                            "../type = 'MATCH_TYPE_NAS_PORT'";
                                        }
                                        description
                                          "NAS Port";
                                        list nas-port-array {
                                          description
                                            "nas port array";
                                          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";
                                          }
                                        }  // list nas-port-array
                                      }  // container nas-port

                                      container service-name {
                                        when
                                          "../type = 'match-type-service-name'" {
                                          description
                                            "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                        }
                                        description
                                          "Service Name";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        list ipv4-addr-array {
                                          description
                                            "ipv4 addr array";
                                          leaf prefix {
                                            type inet:ipv4-address;
                                            description
                                              "prefix";
                                          }

                                          leaf mask {
                                            type inet:ipv4-address;
                                            description
                                              "mask";
                                          }
                                        }  // list 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";
                                        list ipv4-addr-array {
                                          description
                                            "ipv4 addr array";
                                          leaf prefix {
                                            type inet:ipv4-address;
                                            description
                                              "prefix";
                                          }

                                          leaf mask {
                                            type inet:ipv4-address;
                                            description
                                              "mask";
                                          }
                                        }  // list 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";
                                        list ipv6-addr-array {
                                          description
                                            "ipv6 addr array";
                                          leaf prefix {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 prefix";
                                          }

                                          leaf mask {
                                            type uint32;
                                            description
                                              "IPV6 mask";
                                          }
                                        }  // list 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";
                                        list ipv6-addr-array {
                                          description
                                            "ipv6 addr array";
                                          leaf prefix {
                                            type inet:ipv6-address;
                                            description
                                              "IPV6 prefix";
                                          }

                                          leaf mask {
                                            type uint32;
                                            description
                                              "IPV6 mask";
                                          }
                                        }  // list 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";
                                        list mac-addr-array {
                                          description
                                            "mac addr array";
                                          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
                                        }  // list mac-addr-array
                                      }  // container src-addr-mac

                                      container timer {
                                        when
                                          "../type = 'match-type-timer'" {
                                          description
                                            "../type = 'MATCH_TYPE_TIMER'";
                                        }
                                        description
                                          "Timer";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container timer

                                      container timer-regexp {
                                        when
                                          "../type = 'match-type-timer-regexp'" {
                                          description
                                            "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                        }
                                        description
                                          "Timer Regular Expression";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container timer-regexp

                                      container tunnel-name {
                                        when
                                          "../type = 'match-type-tunnel-name'" {
                                          description
                                            "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                        }
                                        description
                                          "Tunnel Name";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container tunnel-name-regex

                                      container user-name {
                                        when
                                          "../type = 'match-type-user-name'" {
                                          description
                                            "../type = 'MATCH_TYPE_USERNAME'";
                                        }
                                        description
                                          "User Name";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container unauth-domain-regex

                                      container vendor-id {
                                        when
                                          "../type = 'match-type-vendor-id'" {
                                          description
                                            "../type = 'MATCH_TYPE_VENDOR_ID'";
                                        }
                                        description
                                          "Vendor ID";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container vendor-id-regex

                                      container access-interface {
                                        when
                                          "../type = 'match-type-access-interface'" {
                                          description
                                            "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                        }
                                        description
                                          "Access interface";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container access-interface

                                      container input-interface {
                                        when
                                          "../type = 'match-type-input-interface'" {
                                          description
                                            "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                        }
                                        description
                                          "Input interface";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container input-interface

                                      container ethertype {
                                        when
                                          "../type = 'match-type-ether-type'" {
                                          description
                                            "../type = 'MATCH_TYPE_ETHERTYPE'";
                                        }
                                        description
                                          "Ethernet type";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                        container flow-keys {
                                          description
                                            "flow keys";
                                          leaf keys {
                                            type yang:hex-string;
                                            description
                                              "keys";
                                          }

                                          leaf num {
                                            type uint8;
                                            description
                                              "num";
                                          }
                                        }  // 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)";
                                        }
                                      }  // 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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container circuit-id-regex

                                      container remote-id {
                                        when
                                          "../type = 'match-type-remote-id'" {
                                          description
                                            "../type = 'MATCH_TYPE_REMOTE_ID'";
                                        }
                                        description
                                          "Remote ID";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "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";
                                        leaf-list string-array {
                                          type string;
                                          description
                                            "string array";
                                        }
                                      }  // container remote-id-regex

                                      container src-port {
                                        when
                                          "../type = 'match-type-src-port'" {
                                          description
                                            "../type = 'MATCH_TYPE_SRC_PORT'";
                                        }
                                        description
                                          "Source port";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint16_rng_array
                                      }  // container src-port

                                      container dst-port {
                                        when
                                          "../type = 'match-type-dst-port'" {
                                          description
                                            "../type = 'MATCH_TYPE_DST_PORT'";
                                        }
                                        description
                                          "Destination port";
                                        list uint16_rng_array {
                                          description
                                            "uint16 rng array";
                                          leaf min {
                                            type uint16;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint16;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list 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";
                                      }
                                    }  // container match-data

                                    leaf flags {
                                      type uint32;
                                      description
                                        "Flags";
                                    }
                                  }  // list 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
                            }  // container clmp-p

                            container act-infop {
                              description
                                "act infop";
                              list policy-action-info-st {
                                description
                                  "policy action info st";
                                container actp {
                                  description
                                    "actp";
                                  container mark {
                                    when
                                      "../type = 'policy-action-mark'" {
                                      description
                                        "../type = 'POLICY_ACTION_MARK'";
                                    }
                                    description
                                      "mark";
                                    list action-mark-info {
                                      description
                                        "action mark info";
                                      leaf type {
                                        type Mark-type-en;
                                        description
                                          "type";
                                      }

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

                                      leaf value {
                                        type uint16;
                                        description
                                          "value";
                                      }
                                    }  // list action-mark-info
                                  }  // container mark

                                  container mark2 {
                                    when
                                      "../type = 'policy-action-mark2'" {
                                      description
                                        "../type = 'POLICY_ACTION_MARK2'";
                                    }
                                    description
                                      "mark2";
                                    list action-mark2-info {
                                      description
                                        "action mark2 info";
                                      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";
                                      }
                                    }  // list action-mark2-info
                                  }  // container mark2

                                  container wred {
                                    when
                                      "../type = 'policy-action-wred'" {
                                      description
                                        "../type = 'POLICY_ACTION_WRED'";
                                    }
                                    description
                                      "wred";
                                    list action-wred-info {
                                      description
                                        "action wred info";
                                      container match-ranges {
                                        description
                                          "match ranges";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint8_rng_array
                                      }  // container match-ranges

                                      container min-threshold {
                                        description
                                          "min threshold";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container min-threshold

                                      container max-threshold {
                                        description
                                          "max threshold";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // 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";
                                      }
                                    }  // list action-wred-info
                                  }  // container wred

                                  container encap {
                                    when
                                      "../type = 'policy-action-encap-seq'" {
                                      description
                                        "../type = 'POLICY_ACTION_ENCAP_SEQ'";
                                    }
                                    description
                                      "encap";
                                    leaf seq {
                                      type uint8;
                                      description
                                        "seq";
                                    }
                                  }  // container encap

                                  container prio {
                                    when
                                      "../type = 'policy-action-priority'" {
                                      description
                                        "../type = 'POLICY_ACTION_PRIORITY'";
                                    }
                                    description
                                      "prio";
                                    leaf prio-lvl {
                                      type uint32;
                                      description
                                        "prio lvl";
                                    }
                                  }  // container prio

                                  container bwrem {
                                    when
                                      "../type = 'policy-action-bw-remaining'" {
                                      description
                                        "../type = 'POLICY_ACTION_BW_REMAINING'";
                                    }
                                    description
                                      "bwrem";
                                    container bwrem {
                                      description
                                        "bwrem";
                                      leaf value {
                                        type uint32;
                                        description
                                          "value";
                                      }

                                      leaf unit {
                                        type Policy-param-unit-type;
                                        description
                                          "unit";
                                      }
                                    }  // container bwrem
                                  }  // container bwrem

                                  container min-bw {
                                    when
                                      "../type = 'policy-action-min-bw'" {
                                      description
                                        "../type = 'POLICY_ACTION_MIN_BW'";
                                    }
                                    description
                                      "min bw";
                                    container bw {
                                      description
                                        "bw";
                                      leaf value {
                                        type uint32;
                                        description
                                          "value";
                                      }

                                      leaf unit {
                                        type Policy-param-unit-type;
                                        description
                                          "unit";
                                      }
                                    }  // container bw
                                  }  // container min-bw

                                  container authen-aaa {
                                    when
                                      "../type = 'policy-action-authenticate-aaa'" {
                                      description
                                        "../type = 'POLICY_ACTION_AUTHENTICATE_AAA'";
                                    }
                                    description
                                      "authen aaa";
                                    leaf aaa-list-name {
                                      type string;
                                      description
                                        "aaa list name";
                                    }

                                    leaf authen-password {
                                      type string;
                                      description
                                        "authen password";
                                    }
                                  }  // container authen-aaa

                                  container collect-id {
                                    when
                                      "../type = 'policy-action-collect-id'" {
                                      description
                                        "../type = 'POLICY_ACTION_COLLECT_ID'";
                                    }
                                    description
                                      "collect id";
                                    leaf id {
                                      type Identifier-en;
                                      description
                                        "id";
                                    }

                                    leaf aaa-list-name {
                                      type string;
                                      description
                                        "aaa list name";
                                    }
                                  }  // container collect-id

                                  container decode-id {
                                    when
                                      "../type = 'policy-action-decode-identifier'" {
                                      description
                                        "../type = 'POLICY_ACTION_DECODE_IDENTIFIER'";
                                    }
                                    description
                                      "decode id";
                                    leaf id {
                                      type Decode-identifier-en;
                                      description
                                        "id";
                                    }

                                    leaf format-name {
                                      type string;
                                      description
                                        "format name";
                                    }
                                  }  // container decode-id

                                  container set-timer {
                                    when
                                      "../type = 'policy-action-set-timer'" {
                                      description
                                        "../type = 'POLICY_ACTION_SET_TIMER'";
                                    }
                                    description
                                      "set timer";
                                    leaf timer-name {
                                      type string;
                                      description
                                        "timer name";
                                    }

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

                                    leaf absolute-time {
                                      type string;
                                      description
                                        "absolute time";
                                    }
                                  }  // container set-timer

                                  container stop-timer {
                                    when
                                      "../type = 'policy-action-stop-timer'" {
                                      description
                                        "../type = 'POLICY_ACTION_STOP_TIMER'";
                                    }
                                    description
                                      "stop timer";
                                    leaf timer-name {
                                      type string;
                                      description
                                        "timer name";
                                    }
                                  }  // 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";
                                    leaf aaa-list-name {
                                      type string;
                                      description
                                        "aaa list name";
                                    }

                                    leaf secs {
                                      type uint32;
                                      description
                                        "secs";
                                    }
                                  }  // container acct-aaa-list

                                  container query-ancp {
                                    when
                                      "../type = 'policy-action-query-ancp'" {
                                      description
                                        "../type = 'POLICY_ACTION_QUERY_ANCP'";
                                    }
                                    description
                                      "query ancp";
                                    leaf enable {
                                      type boolean;
                                      description
                                        "enable";
                                    }
                                  }  // container query-ancp

                                  container prepaid-cfg {
                                    when
                                      "../type = 'policy-action-prepaid-config'" {
                                      description
                                        "../type = 'POLICY_ACTION_PREPAID_CONFIG'";
                                    }
                                    description
                                      "prepaid cfg";
                                    leaf prepaid-config-profile-name {
                                      type string;
                                      description
                                        "prepaid config profile name";
                                    }
                                  }  // container prepaid-cfg

                                  container timeout-idle {
                                    when
                                      "../type = 'policy-action-timeout-idle'" {
                                      description
                                        "../type = 'POLICY_ACTION_TIMEOUT_IDLE'";
                                    }
                                    description
                                      "timeout idle";
                                    leaf secs {
                                      type uint32;
                                      description
                                        "secs";
                                    }
                                  }  // container timeout-idle

                                  container proxy-aaa {
                                    when
                                      "../type = 'policy-action-proxy-aaa'" {
                                      description
                                        "../type = 'POLICY_ACTION_PROXY_AAA'";
                                    }
                                    description
                                      "proxy aaa";
                                    leaf aaa-list-name {
                                      type string;
                                      description
                                        "aaa list name";
                                    }
                                  }  // container proxy-aaa

                                  container act-template {
                                    when
                                      "../type = 'policy-action-template-activate'" {
                                      description
                                        "../type = 'POLICY_ACTION_TEMPLATE_ACTIVATE'";
                                    }
                                    description
                                      "act template";
                                    leaf template-name {
                                      type string;
                                      description
                                        "template name";
                                    }

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

                                    leaf flags {
                                      type uint32;
                                      description
                                        "flags";
                                    }
                                  }  // container act-template

                                  container deact-template {
                                    when
                                      "../type = 'policy-action-template-deactivate'" {
                                      description
                                        "../type = 'POLICY_ACTION_TEMPLATE_DEACTIVATE'";
                                    }
                                    description
                                      "deact template";
                                    leaf template-name {
                                      type string;
                                      description
                                        "template name";
                                    }

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

                                    leaf flags {
                                      type uint32;
                                      description
                                        "flags";
                                    }
                                  }  // container deact-template

                                  container qlimit {
                                    when
                                      "../type = 'policy-action-q-limit'" {
                                      description
                                        "../type = 'POLICY_ACTION_Q_LIMIT'";
                                    }
                                    description
                                      "qlimit";
                                    list action-qlimit-info-array {
                                      description
                                        "action qlimit info array";
                                      container qlim {
                                        description
                                          "qlim";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container qlim

                                      container atmclp-qlim {
                                        description
                                          "atmclp qlim";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container atmclp-qlim

                                      container match-values {
                                        description
                                          "match values";
                                        list uint8_rng_array {
                                          description
                                            "uint8 rng array";
                                          leaf min {
                                            type uint8;
                                            description
                                              "Lower limit of the range";
                                          }

                                          leaf max {
                                            type uint8;
                                            description
                                              "Upper limit of the range";
                                          }
                                        }  // list uint8_rng_array
                                      }  // container match-values

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

                                      leaf qlimit-flags {
                                        type uint32;
                                        description
                                          "qlimit flags";
                                      }
                                    }  // list 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";
                                    leaf action {
                                      type Acct-en;
                                      description
                                        "action";
                                    }

                                    leaf aaa-list-name {
                                      type string;
                                      description
                                        "aaa list name";
                                    }
                                  }  // container accounting-event-aaa

                                  container authorize-id {
                                    when
                                      "../type = 'policy-action-authorize-id'" {
                                      description
                                        "../type = 'POLICY_ACTION_AUTHORIZE_ID'";
                                    }
                                    description
                                      "authorize id";
                                    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";
                                    }
                                  }  // container authorize-id

                                  container afm-react {
                                    when
                                      "../type = 'policy-action-afmon-react'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_REACT'";
                                    }
                                    description
                                      "afm react";
                                    list action-afmon-react-info {
                                      description
                                        "action afmon react info";
                                      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";
                                      }
                                    }  // list action-afmon-react-info
                                  }  // container afm-react

                                  container httpr {
                                    when
                                      "../type = 'policy-action-httpr'" {
                                      description
                                        "../type = 'POLICY_ACTION_HTTPR'";
                                    }
                                    description
                                      "httpr";
                                    leaf redirect-url {
                                      type string;
                                      description
                                        "redirect url";
                                    }
                                  }  // container httpr

                                  container punt {
                                    when
                                      "../type = 'policy-action-punt'" {
                                      description
                                        "../type = 'POLICY_ACTION_PUNT'";
                                    }
                                    description
                                      "punt";
                                    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";
                                    }
                                  }  // container punt

                                  container copy {
                                    when
                                      "../type = 'policy-action-copy'" {
                                      description
                                        "../type = 'POLICY_ACTION_COPY'";
                                    }
                                    description
                                      "copy";
                                    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";
                                    }
                                  }  // container copy

                                  container sfrag {
                                    when
                                      "../type = 'policy-action-sfrag'" {
                                      description
                                        "../type = 'POLICY_ACTION_SFRAG'";
                                    }
                                    description
                                      "sfrag";
                                    leaf name {
                                      type string;
                                      description
                                        "Service Fragment Name";
                                    }
                                  }  // container sfrag

                                  container redirect {
                                    when
                                      "../type = 'policy-action-redirect'" {
                                      description
                                        "../type = 'POLICY_ACTION_REDIRECT'";
                                    }
                                    description
                                      "redirect";
                                    leaf value {
                                      type uint32;
                                      description
                                        "value";
                                    }

                                    leaf type {
                                      type Redirect-type-e;
                                      description
                                        "type";
                                    }
                                  }  // container redirect

                                  container out-intf {
                                    when
                                      "../type = 'policy-action-output-interface'" {
                                      description
                                        "../type = 'POLICY_ACTION_OUTPUT_INTERFACE'";
                                    }
                                    description
                                      "out intf";
                                    leaf out-ifname {
                                      type string;
                                      description
                                        "output interface name";
                                    }
                                  }  // container out-intf

                                  container serv-func {
                                    when
                                      "../type = 'policy-action-service-function-path'" {
                                      description
                                        "../type = 'POLICY_ACTION_SERVICE_FUNCTION_PATH'";
                                    }
                                    description
                                      "serv func";
                                    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";
                                    }
                                  }  // 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";
                                    list action-police-info-st {
                                      description
                                        "action police info array";
                                      container rate {
                                        description
                                          "rate";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container rate

                                      container burst {
                                        description
                                          "burst";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container burst

                                      container peak-rate {
                                        description
                                          "peak rate";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container peak-rate

                                      container peak-burst {
                                        description
                                          "peak burst";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container peak-burst

                                      container cdvt {
                                        description
                                          "cdvt";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container cdvt

                                      container conform-actns {
                                        description
                                          "conform actns";
                                        list police-action-array {
                                          description
                                            "police action array";
                                          container mark {
                                            when
                                              "../type = 'police-action-mark'" {
                                              description
                                                "../type = 'POLICE_ACTION_MARK'";
                                            }
                                            description
                                              "mark";
                                            leaf type {
                                              type Mark-type-en;
                                              description
                                                "type";
                                            }

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

                                            leaf value {
                                              type uint16;
                                              description
                                                "value";
                                            }
                                          }  // container mark

                                          leaf type {
                                            type Police-action-type-en;
                                            description
                                              "type";
                                          }
                                        }  // list police-action-array
                                      }  // container conform-actns

                                      container exceed-actns {
                                        description
                                          "exceed actns";
                                        list police-action-array {
                                          description
                                            "police action array";
                                          container mark {
                                            when
                                              "../type = 'police-action-mark'" {
                                              description
                                                "../type = 'POLICE_ACTION_MARK'";
                                            }
                                            description
                                              "mark";
                                            leaf type {
                                              type Mark-type-en;
                                              description
                                                "type";
                                            }

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

                                            leaf value {
                                              type uint16;
                                              description
                                                "value";
                                            }
                                          }  // container mark

                                          leaf type {
                                            type Police-action-type-en;
                                            description
                                              "type";
                                          }
                                        }  // list police-action-array
                                      }  // container exceed-actns

                                      container violate-actns {
                                        description
                                          "violate actns";
                                        list police-action-array {
                                          description
                                            "police action array";
                                          container mark {
                                            when
                                              "../type = 'police-action-mark'" {
                                              description
                                                "../type = 'POLICE_ACTION_MARK'";
                                            }
                                            description
                                              "mark";
                                            leaf type {
                                              type Mark-type-en;
                                              description
                                                "type";
                                            }

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

                                            leaf value {
                                              type uint16;
                                              description
                                                "value";
                                            }
                                          }  // container mark

                                          leaf type {
                                            type Police-action-type-en;
                                            description
                                              "type";
                                          }
                                        }  // list police-action-array
                                      }  // container violate-actns

                                      container confclass-p {
                                        description
                                          "confclass p";
                                        list class-map-bg {
                                          description
                                            "class map bg";
                                          container match-infop {
                                            description
                                              "Pointer to the first Match info";
                                            list class-match-info-st {
                                              description
                                                "class match info st";
                                              container match-data {
                                                description
                                                  "Match criteria";
                                                container ipv4-dscp {
                                                  when
                                                    "../type = 'match-type-ipv4-dscp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                  }
                                                  description
                                                    "IPv4 DSCP";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container ipv4-dscp

                                                container ipv6-dscp {
                                                  when
                                                    "../type = 'match-type-ipv6-dscp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                  }
                                                  description
                                                    "IPv6 DSCP";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container ipv6-dscp

                                                container dscp {
                                                  when
                                                    "../type = 'match-type-dscp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DSCP'";
                                                  }
                                                  description
                                                    "Match DSCP range array";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container dscp

                                                container ipv4-prec {
                                                  when
                                                    "../type = 'match-type-ipv4-prec'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                  }
                                                  description
                                                    "IPv4 Precedence";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container ipv4-prec

                                                container ipv6-prec {
                                                  when
                                                    "../type = 'match-type-ipv6-prec'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                  }
                                                  description
                                                    "IPv6 Precedence";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container ipv6-prec

                                                container prec {
                                                  when
                                                    "../type = 'match-type-prec'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_PREC'";
                                                  }
                                                  description
                                                    "Match Precedence array";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container prec

                                                container discard-class {
                                                  when
                                                    "../type = 'match-type-disc-cls'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DISC_CLS'";
                                                  }
                                                  description
                                                    "Match Discard Class array";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container traffic-class

                                                container proto {
                                                  when
                                                    "../type = 'match-type-proto'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_PROTO'";
                                                  }
                                                  description
                                                    "Match Protocol array";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  leaf value {
                                                    type uint16;
                                                    description
                                                      "Value of TCP flag";
                                                  }

                                                  leaf match-any {
                                                    type boolean;
                                                    description
                                                      "Match any TCP flag bit";
                                                  }
                                                }  // container tcp-flag

                                                container icmpv4-type {
                                                  when
                                                    "../type = 'match-type-icmpv4-type'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                  }
                                                  description
                                                    "Match ipv4 icmp type";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  list uint32_rng_array {
                                                    description
                                                      "uint32 rng array";
                                                    leaf min {
                                                      type uint32;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint32;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint32_rng_array
                                                }  // container mpls-top-label

                                                container cos {
                                                  when
                                                    "../type = 'match-type-cos'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_COS'";
                                                  }
                                                  description
                                                    "Match CoS array";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container cos

                                                container cos-inr {
                                                  when
                                                    "../type = 'match-type-cos-inner'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_COS_INNER'";
                                                  }
                                                  description
                                                    "Match inner header CoS";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container cos-inr

                                                container dei {
                                                  when
                                                    "../type = 'match-type-dei'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DEI'";
                                                  }
                                                  description
                                                    "Match DEI Bit";
                                                  leaf bit-value {
                                                    type uint32;
                                                    description
                                                      "Value of the DEI bit";
                                                  }
                                                }  // container dei

                                                container dei-inr {
                                                  when
                                                    "../type = 'match-type-dei-inner'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DEI_INNER'";
                                                  }
                                                  description
                                                    "Match inner DEI Bit";
                                                  leaf bit-value {
                                                    type uint32;
                                                    description
                                                      "Value of the DEI bit";
                                                  }
                                                }  // container dei-inr

                                                container vlan {
                                                  when
                                                    "../type = 'match-type-vlan'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_VLAN'";
                                                  }
                                                  description
                                                    "Match VLAN array";
                                                  list vlan-id-array {
                                                    description
                                                      "vlan id array";
                                                    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";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  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
                                                }  // container src-mac

                                                container dst-mac {
                                                  when
                                                    "../type = 'match-type-dst-mac'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DST_MAC'";
                                                  }
                                                  description
                                                    "Match Destination MAC address";
                                                  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
                                                }  // container dst-mac

                                                container atm-clp {
                                                  when
                                                    "../type = 'match-type-atm-clp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ATM_CLP'";
                                                  }
                                                  description
                                                    "Match ATM CLP level";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container fr-de

                                                container ipv4-acl {
                                                  when
                                                    "../type = 'match-type-ipv4-acl'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                  }
                                                  description
                                                    "IPv4 Access-list";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container ipv4-acl

                                                container ipv6-acl {
                                                  when
                                                    "../type = 'match-type-ipv6-acl'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                  }
                                                  description
                                                    "IPv6 Access-list";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container ether-service-acl

                                                container avail-id {
                                                  when
                                                    "../type = 'match-type-avail-id'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                  }
                                                  description
                                                    "Available Identifiers";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container avail-id

                                                container media-type {
                                                  when
                                                    "../type = 'match-type-media'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_MEDIA'";
                                                  }
                                                  description
                                                    "Media Type";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container media-type

                                                container subs-protocol {
                                                  when
                                                    "../type = 'match-type-subs-protocol'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                  }
                                                  description
                                                    "Protocol";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container subs-protocol

                                                container dnis {
                                                  when
                                                    "../type = 'match-type-dnis'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DNIS'";
                                                  }
                                                  description
                                                    "DNIS";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container dnis

                                                container dnis-regex {
                                                  when
                                                    "../type = 'match-type-dnis-regexp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                  }
                                                  description
                                                    "DNIS Regular Expression";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container dnis-regex

                                                container domain {
                                                  when
                                                    "../type = 'match-type-domain'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DOMAIN'";
                                                  }
                                                  description
                                                    "Domain Name";
                                                  list domain-array {
                                                    description
                                                      "domain array";
                                                    leaf domain-name {
                                                      type string;
                                                      description
                                                        "domain name";
                                                    }

                                                    leaf format-name {
                                                      type string;
                                                      description
                                                        "format name";
                                                    }
                                                  }  // list domain-array
                                                }  // container domain

                                                container domain-regex {
                                                  when
                                                    "../type = 'match-type-domain-regexp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                  }
                                                  description
                                                    "Domain Regular Expression";
                                                  list domain-array {
                                                    description
                                                      "domain array";
                                                    leaf domain-name {
                                                      type string;
                                                      description
                                                        "domain name";
                                                    }

                                                    leaf format-name {
                                                      type string;
                                                      description
                                                        "format name";
                                                    }
                                                  }  // list domain-array
                                                }  // container domain-regex

                                                container nas-port {
                                                  when
                                                    "../type = 'match-type-nas-port'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_NAS_PORT'";
                                                  }
                                                  description
                                                    "NAS Port";
                                                  list nas-port-array {
                                                    description
                                                      "nas port array";
                                                    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";
                                                    }
                                                  }  // list nas-port-array
                                                }  // container nas-port

                                                container service-name {
                                                  when
                                                    "../type = 'match-type-service-name'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                  }
                                                  description
                                                    "Service Name";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  list ipv4-addr-array {
                                                    description
                                                      "ipv4 addr array";
                                                    leaf prefix {
                                                      type inet:ipv4-address;
                                                      description
                                                        "prefix";
                                                    }

                                                    leaf mask {
                                                      type inet:ipv4-address;
                                                      description
                                                        "mask";
                                                    }
                                                  }  // list 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";
                                                  list ipv4-addr-array {
                                                    description
                                                      "ipv4 addr array";
                                                    leaf prefix {
                                                      type inet:ipv4-address;
                                                      description
                                                        "prefix";
                                                    }

                                                    leaf mask {
                                                      type inet:ipv4-address;
                                                      description
                                                        "mask";
                                                    }
                                                  }  // list 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";
                                                  list ipv6-addr-array {
                                                    description
                                                      "ipv6 addr array";
                                                    leaf prefix {
                                                      type inet:ipv6-address;
                                                      description
                                                        "IPV6 prefix";
                                                    }

                                                    leaf mask {
                                                      type uint32;
                                                      description
                                                        "IPV6 mask";
                                                    }
                                                  }  // list 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";
                                                  list ipv6-addr-array {
                                                    description
                                                      "ipv6 addr array";
                                                    leaf prefix {
                                                      type inet:ipv6-address;
                                                      description
                                                        "IPV6 prefix";
                                                    }

                                                    leaf mask {
                                                      type uint32;
                                                      description
                                                        "IPV6 mask";
                                                    }
                                                  }  // list 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";
                                                  list mac-addr-array {
                                                    description
                                                      "mac addr array";
                                                    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
                                                  }  // list mac-addr-array
                                                }  // container src-addr-mac

                                                container timer {
                                                  when
                                                    "../type = 'match-type-timer'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_TIMER'";
                                                  }
                                                  description
                                                    "Timer";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container timer

                                                container timer-regexp {
                                                  when
                                                    "../type = 'match-type-timer-regexp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                  }
                                                  description
                                                    "Timer Regular Expression";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container timer-regexp

                                                container tunnel-name {
                                                  when
                                                    "../type = 'match-type-tunnel-name'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                  }
                                                  description
                                                    "Tunnel Name";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container tunnel-name-regex

                                                container user-name {
                                                  when
                                                    "../type = 'match-type-user-name'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_USERNAME'";
                                                  }
                                                  description
                                                    "User Name";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container unauth-domain-regex

                                                container vendor-id {
                                                  when
                                                    "../type = 'match-type-vendor-id'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                  }
                                                  description
                                                    "Vendor ID";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container vendor-id-regex

                                                container access-interface {
                                                  when
                                                    "../type = 'match-type-access-interface'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                  }
                                                  description
                                                    "Access interface";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container access-interface

                                                container input-interface {
                                                  when
                                                    "../type = 'match-type-input-interface'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                  }
                                                  description
                                                    "Input interface";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container input-interface

                                                container ethertype {
                                                  when
                                                    "../type = 'match-type-ether-type'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                  }
                                                  description
                                                    "Ethernet type";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  container flow-keys {
                                                    description
                                                      "flow keys";
                                                    leaf keys {
                                                      type yang:hex-string;
                                                      description
                                                        "keys";
                                                    }

                                                    leaf num {
                                                      type uint8;
                                                      description
                                                        "num";
                                                    }
                                                  }  // 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)";
                                                  }
                                                }  // 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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container circuit-id-regex

                                                container remote-id {
                                                  when
                                                    "../type = 'match-type-remote-id'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                  }
                                                  description
                                                    "Remote ID";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container remote-id-regex

                                                container src-port {
                                                  when
                                                    "../type = 'match-type-src-port'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_SRC_PORT'";
                                                  }
                                                  description
                                                    "Source port";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint16_rng_array
                                                }  // container src-port

                                                container dst-port {
                                                  when
                                                    "../type = 'match-type-dst-port'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DST_PORT'";
                                                  }
                                                  description
                                                    "Destination port";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                }
                                              }  // container match-data

                                              leaf flags {
                                                type uint32;
                                                description
                                                  "Flags";
                                              }
                                            }  // list 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
                                      }  // container confclass-p

                                      container excdclass-p {
                                        description
                                          "excdclass p";
                                        list class-map-bg {
                                          description
                                            "class map bg";
                                          container match-infop {
                                            description
                                              "Pointer to the first Match info";
                                            list class-match-info-st {
                                              description
                                                "class match info st";
                                              container match-data {
                                                description
                                                  "Match criteria";
                                                container ipv4-dscp {
                                                  when
                                                    "../type = 'match-type-ipv4-dscp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV4_DSCP'";
                                                  }
                                                  description
                                                    "IPv4 DSCP";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container ipv4-dscp

                                                container ipv6-dscp {
                                                  when
                                                    "../type = 'match-type-ipv6-dscp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV6_DSCP'";
                                                  }
                                                  description
                                                    "IPv6 DSCP";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container ipv6-dscp

                                                container dscp {
                                                  when
                                                    "../type = 'match-type-dscp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DSCP'";
                                                  }
                                                  description
                                                    "Match DSCP range array";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container dscp

                                                container ipv4-prec {
                                                  when
                                                    "../type = 'match-type-ipv4-prec'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV4_PREC'";
                                                  }
                                                  description
                                                    "IPv4 Precedence";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container ipv4-prec

                                                container ipv6-prec {
                                                  when
                                                    "../type = 'match-type-ipv6-prec'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV6_PREC'";
                                                  }
                                                  description
                                                    "IPv6 Precedence";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container ipv6-prec

                                                container prec {
                                                  when
                                                    "../type = 'match-type-prec'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_PREC'";
                                                  }
                                                  description
                                                    "Match Precedence array";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container prec

                                                container discard-class {
                                                  when
                                                    "../type = 'match-type-disc-cls'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DISC_CLS'";
                                                  }
                                                  description
                                                    "Match Discard Class array";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint8_rng_array
                                                }  // container traffic-class

                                                container proto {
                                                  when
                                                    "../type = 'match-type-proto'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_PROTO'";
                                                  }
                                                  description
                                                    "Match Protocol array";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  leaf value {
                                                    type uint16;
                                                    description
                                                      "Value of TCP flag";
                                                  }

                                                  leaf match-any {
                                                    type boolean;
                                                    description
                                                      "Match any TCP flag bit";
                                                  }
                                                }  // container tcp-flag

                                                container icmpv4-type {
                                                  when
                                                    "../type = 'match-type-icmpv4-type'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ICMPV4_TYPE'";
                                                  }
                                                  description
                                                    "Match ipv4 icmp type";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint8_rng_array {
                                                    description
                                                      "uint8 rng array";
                                                    leaf min {
                                                      type uint8;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint8;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  list uint32_rng_array {
                                                    description
                                                      "uint32 rng array";
                                                    leaf min {
                                                      type uint32;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint32;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint32_rng_array
                                                }  // container mpls-top-label

                                                container cos {
                                                  when
                                                    "../type = 'match-type-cos'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_COS'";
                                                  }
                                                  description
                                                    "Match CoS array";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container cos

                                                container cos-inr {
                                                  when
                                                    "../type = 'match-type-cos-inner'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_COS_INNER'";
                                                  }
                                                  description
                                                    "Match inner header CoS";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container cos-inr

                                                container dei {
                                                  when
                                                    "../type = 'match-type-dei'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DEI'";
                                                  }
                                                  description
                                                    "Match DEI Bit";
                                                  leaf bit-value {
                                                    type uint32;
                                                    description
                                                      "Value of the DEI bit";
                                                  }
                                                }  // container dei

                                                container dei-inr {
                                                  when
                                                    "../type = 'match-type-dei-inner'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DEI_INNER'";
                                                  }
                                                  description
                                                    "Match inner DEI Bit";
                                                  leaf bit-value {
                                                    type uint32;
                                                    description
                                                      "Value of the DEI bit";
                                                  }
                                                }  // container dei-inr

                                                container vlan {
                                                  when
                                                    "../type = 'match-type-vlan'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_VLAN'";
                                                  }
                                                  description
                                                    "Match VLAN array";
                                                  list vlan-id-array {
                                                    description
                                                      "vlan id array";
                                                    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";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  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
                                                }  // container src-mac

                                                container dst-mac {
                                                  when
                                                    "../type = 'match-type-dst-mac'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DST_MAC'";
                                                  }
                                                  description
                                                    "Match Destination MAC address";
                                                  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
                                                }  // container dst-mac

                                                container atm-clp {
                                                  when
                                                    "../type = 'match-type-atm-clp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ATM_CLP'";
                                                  }
                                                  description
                                                    "Match ATM CLP level";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "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";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container fr-de

                                                container ipv4-acl {
                                                  when
                                                    "../type = 'match-type-ipv4-acl'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV4_ACL'";
                                                  }
                                                  description
                                                    "IPv4 Access-list";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container ipv4-acl

                                                container ipv6-acl {
                                                  when
                                                    "../type = 'match-type-ipv6-acl'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_IPV6_ACL'";
                                                  }
                                                  description
                                                    "IPv6 Access-list";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container ether-service-acl

                                                container avail-id {
                                                  when
                                                    "../type = 'match-type-avail-id'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_AVAIL_ID'";
                                                  }
                                                  description
                                                    "Available Identifiers";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container avail-id

                                                container media-type {
                                                  when
                                                    "../type = 'match-type-media'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_MEDIA'";
                                                  }
                                                  description
                                                    "Media Type";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container media-type

                                                container subs-protocol {
                                                  when
                                                    "../type = 'match-type-subs-protocol'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_SUBS_PROTOCOL'";
                                                  }
                                                  description
                                                    "Protocol";
                                                  leaf-list uint8_array {
                                                    type uint8;
                                                    description
                                                      "uint8 array";
                                                  }
                                                }  // container subs-protocol

                                                container dnis {
                                                  when
                                                    "../type = 'match-type-dnis'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DNIS'";
                                                  }
                                                  description
                                                    "DNIS";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container dnis

                                                container dnis-regex {
                                                  when
                                                    "../type = 'match-type-dnis-regexp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DNIS_REGEXP'";
                                                  }
                                                  description
                                                    "DNIS Regular Expression";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container dnis-regex

                                                container domain {
                                                  when
                                                    "../type = 'match-type-domain'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DOMAIN'";
                                                  }
                                                  description
                                                    "Domain Name";
                                                  list domain-array {
                                                    description
                                                      "domain array";
                                                    leaf domain-name {
                                                      type string;
                                                      description
                                                        "domain name";
                                                    }

                                                    leaf format-name {
                                                      type string;
                                                      description
                                                        "format name";
                                                    }
                                                  }  // list domain-array
                                                }  // container domain

                                                container domain-regex {
                                                  when
                                                    "../type = 'match-type-domain-regexp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DOMAIN_REGEXP'";
                                                  }
                                                  description
                                                    "Domain Regular Expression";
                                                  list domain-array {
                                                    description
                                                      "domain array";
                                                    leaf domain-name {
                                                      type string;
                                                      description
                                                        "domain name";
                                                    }

                                                    leaf format-name {
                                                      type string;
                                                      description
                                                        "format name";
                                                    }
                                                  }  // list domain-array
                                                }  // container domain-regex

                                                container nas-port {
                                                  when
                                                    "../type = 'match-type-nas-port'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_NAS_PORT'";
                                                  }
                                                  description
                                                    "NAS Port";
                                                  list nas-port-array {
                                                    description
                                                      "nas port array";
                                                    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";
                                                    }
                                                  }  // list nas-port-array
                                                }  // container nas-port

                                                container service-name {
                                                  when
                                                    "../type = 'match-type-service-name'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_SERVICE_NAME'";
                                                  }
                                                  description
                                                    "Service Name";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  list ipv4-addr-array {
                                                    description
                                                      "ipv4 addr array";
                                                    leaf prefix {
                                                      type inet:ipv4-address;
                                                      description
                                                        "prefix";
                                                    }

                                                    leaf mask {
                                                      type inet:ipv4-address;
                                                      description
                                                        "mask";
                                                    }
                                                  }  // list 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";
                                                  list ipv4-addr-array {
                                                    description
                                                      "ipv4 addr array";
                                                    leaf prefix {
                                                      type inet:ipv4-address;
                                                      description
                                                        "prefix";
                                                    }

                                                    leaf mask {
                                                      type inet:ipv4-address;
                                                      description
                                                        "mask";
                                                    }
                                                  }  // list 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";
                                                  list ipv6-addr-array {
                                                    description
                                                      "ipv6 addr array";
                                                    leaf prefix {
                                                      type inet:ipv6-address;
                                                      description
                                                        "IPV6 prefix";
                                                    }

                                                    leaf mask {
                                                      type uint32;
                                                      description
                                                        "IPV6 mask";
                                                    }
                                                  }  // list 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";
                                                  list ipv6-addr-array {
                                                    description
                                                      "ipv6 addr array";
                                                    leaf prefix {
                                                      type inet:ipv6-address;
                                                      description
                                                        "IPV6 prefix";
                                                    }

                                                    leaf mask {
                                                      type uint32;
                                                      description
                                                        "IPV6 mask";
                                                    }
                                                  }  // list 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";
                                                  list mac-addr-array {
                                                    description
                                                      "mac addr array";
                                                    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
                                                  }  // list mac-addr-array
                                                }  // container src-addr-mac

                                                container timer {
                                                  when
                                                    "../type = 'match-type-timer'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_TIMER'";
                                                  }
                                                  description
                                                    "Timer";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container timer

                                                container timer-regexp {
                                                  when
                                                    "../type = 'match-type-timer-regexp'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_TIMER_REGEXP'";
                                                  }
                                                  description
                                                    "Timer Regular Expression";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container timer-regexp

                                                container tunnel-name {
                                                  when
                                                    "../type = 'match-type-tunnel-name'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_TUNNEL_NAME'";
                                                  }
                                                  description
                                                    "Tunnel Name";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container tunnel-name-regex

                                                container user-name {
                                                  when
                                                    "../type = 'match-type-user-name'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_USERNAME'";
                                                  }
                                                  description
                                                    "User Name";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container unauth-domain-regex

                                                container vendor-id {
                                                  when
                                                    "../type = 'match-type-vendor-id'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_VENDOR_ID'";
                                                  }
                                                  description
                                                    "Vendor ID";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container vendor-id-regex

                                                container access-interface {
                                                  when
                                                    "../type = 'match-type-access-interface'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ACCESS_INTERFACE'";
                                                  }
                                                  description
                                                    "Access interface";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container access-interface

                                                container input-interface {
                                                  when
                                                    "../type = 'match-type-input-interface'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_INPUT_INTERFACE'";
                                                  }
                                                  description
                                                    "Input interface";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container input-interface

                                                container ethertype {
                                                  when
                                                    "../type = 'match-type-ether-type'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_ETHERTYPE'";
                                                  }
                                                  description
                                                    "Ethernet type";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                  container flow-keys {
                                                    description
                                                      "flow keys";
                                                    leaf keys {
                                                      type yang:hex-string;
                                                      description
                                                        "keys";
                                                    }

                                                    leaf num {
                                                      type uint8;
                                                      description
                                                        "num";
                                                    }
                                                  }  // 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)";
                                                  }
                                                }  // 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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container circuit-id-regex

                                                container remote-id {
                                                  when
                                                    "../type = 'match-type-remote-id'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_REMOTE_ID'";
                                                  }
                                                  description
                                                    "Remote ID";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "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";
                                                  leaf-list string-array {
                                                    type string;
                                                    description
                                                      "string array";
                                                  }
                                                }  // container remote-id-regex

                                                container src-port {
                                                  when
                                                    "../type = 'match-type-src-port'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_SRC_PORT'";
                                                  }
                                                  description
                                                    "Source port";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list uint16_rng_array
                                                }  // container src-port

                                                container dst-port {
                                                  when
                                                    "../type = 'match-type-dst-port'" {
                                                    description
                                                      "../type = 'MATCH_TYPE_DST_PORT'";
                                                  }
                                                  description
                                                    "Destination port";
                                                  list uint16_rng_array {
                                                    description
                                                      "uint16 rng array";
                                                    leaf min {
                                                      type uint16;
                                                      description
                                                        "Lower limit of the range";
                                                    }

                                                    leaf max {
                                                      type uint16;
                                                      description
                                                        "Upper limit of the range";
                                                    }
                                                  }  // list 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";
                                                }
                                              }  // container match-data

                                              leaf flags {
                                                type uint32;
                                                description
                                                  "Flags";
                                              }
                                            }  // list 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
                                      }  // 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";
                                      }
                                    }  // list action-police-info-st
                                  }  // container police

                                  container shape {
                                    when
                                      "../type = 'policy-action-shape'" {
                                      description
                                        "../type = 'POLICY_ACTION_SHAPE'";
                                    }
                                    description
                                      "shape";
                                    list action-shape-info-st {
                                      description
                                        "action police info array";
                                      container bw {
                                        description
                                          "bw";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container bw

                                      container be {
                                        description
                                          "be";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container be
                                    }  // list action-shape-info-st
                                  }  // container shape

                                  container child-policy {
                                    when
                                      "../type = 'policy-action-serv-pol'" {
                                      description
                                        "../type = 'POLICY_ACTION_SERV_POL'";
                                    }
                                    description
                                      "child policy";
                                    list action-policy-info-st {
                                      description
                                        "child policy info";
                                      container info {
                                        when
                                          "../enc = 'policy-obj-enc-name'" {
                                          description
                                            "../enc = 'POLICY_OBJ_ENC_NAME'";
                                        }
                                        description
                                          "info";
                                        leaf name {
                                          type Policy-map-name;
                                          description
                                            "name";
                                        }

                                        leaf type {
                                          type Policy-map-type-en;
                                          description
                                            "type";
                                        }
                                      }  // container info

                                      container hd-info {
                                        when
                                          "../enc = 'policy-obj-enc-hdl'" {
                                          description
                                            "../enc = 'POLICY_OBJ_ENC_HDL'";
                                        }
                                        description
                                          "hd info";
                                        container data-hd {
                                          description
                                            "data hd";
                                          list policy-map-name-type {
                                            description
                                              "policy map type and name";
                                            leaf name {
                                              type Policy-map-name;
                                              description
                                                "name";
                                            }

                                            leaf type {
                                              type Policy-map-type-en;
                                              description
                                                "type";
                                            }
                                          }  // list policy-map-name-type
                                        }  // container data-hd
                                      }  // container hd-info

                                      leaf enc {
                                        type Policy-obj-enc-en;
                                        description
                                          "enc";
                                      }
                                    }  // list action-policy-info-st
                                  }  // container child-policy

                                  container cac {
                                    when
                                      "../type = 'policy-action-cac'" {
                                      description
                                        "../type = 'POLICY_ACTION_CAC'";
                                    }
                                    description
                                      "cac";
                                    list action-cac-info-st {
                                      description
                                        "action cac info st";
                                      container flow-rate {
                                        description
                                          "flow rate";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container flow-rate

                                      container rate {
                                        description
                                          "rate";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container rate

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

                                      leaf idle-timeout {
                                        type uint16;
                                        description
                                          "idle timeout";
                                      }
                                    }  // list action-cac-info-st
                                  }  // container cac

                                  container pfc {
                                    when
                                      "../type = 'policy-action-pfc'" {
                                      description
                                        "../type = 'POLICY_ACTION_PFC'";
                                    }
                                    description
                                      "pfc";
                                    list action-pfc-info-st {
                                      description
                                        "action pfc info st";
                                      container buffer-size {
                                        description
                                          "buffer size";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container buffer-size

                                      container pause-threshold {
                                        description
                                          "pause threshold";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container pause-threshold

                                      container resume-threshold {
                                        description
                                          "resume threshold";
                                        leaf value {
                                          type uint32;
                                          description
                                            "value";
                                        }

                                        leaf unit {
                                          type Policy-param-unit-type;
                                          description
                                            "unit";
                                        }
                                      }  // container resume-threshold

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

                                      leaf buffer-size-flag {
                                        type uint32;
                                        description
                                          "buffer size flag";
                                      }
                                    }  // list action-pfc-info-st
                                  }  // container pfc

                                  container flow-parm {
                                    when
                                      "../type = 'policy-action-afmon-flow-parm'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_FLOW_PARM'";
                                    }
                                    description
                                      "flow parm";
                                    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";
                                    }
                                  }  // container flow-parm

                                  container ipcbr {
                                    when
                                      "../type = 'policy-action-afmon-ipcbr-metric'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_IPCBR_METRIC'";
                                    }
                                    description
                                      "ipcbr";
                                    container ip-bit-rate {
                                      description
                                        "data rate in bps";
                                      leaf value {
                                        type uint32;
                                        description
                                          "value";
                                      }

                                      leaf unit {
                                        type Policy-param-unit-type;
                                        description
                                          "unit";
                                      }
                                    }  // container ip-bit-rate

                                    container media-bit-rate {
                                      description
                                        "media data rate in bps";
                                      leaf value {
                                        type uint32;
                                        description
                                          "value";
                                      }

                                      leaf unit {
                                        type Policy-param-unit-type;
                                        description
                                          "unit";
                                      }
                                    }  // 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";
                                    }
                                  }  // container ipcbr

                                  container rtp {
                                    when
                                      "../type = 'policy-action-afmon-rtp-metric'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_RTP_METRIC'";
                                    }
                                    description
                                      "rtp";
                                    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";
                                      leaf pt {
                                        type uint32;
                                        description
                                          "pt";
                                      }

                                      leaf frequency {
                                        type uint32;
                                        description
                                          "frequency";
                                      }
                                    }  // list clock-rate
                                  }  // container rtp

                                  container rtp-mmr {
                                    when
                                      "../type = 'policy-action-afmon-rtp-mmr-metric'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_RTP_MMR_METRIC'";
                                    }
                                    description
                                      "rtp mmr";
                                    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";
                                      leaf pt {
                                        type uint32;
                                        description
                                          "pt";
                                      }

                                      leaf frequency {
                                        type uint32;
                                        description
                                          "frequency";
                                      }
                                    }  // list clock-rate
                                  }  // 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";
                                    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";
                                      leaf pt {
                                        type uint32;
                                        description
                                          "pt";
                                      }

                                      leaf frequency {
                                        type uint32;
                                        description
                                          "frequency";
                                      }
                                    }  // list clock-rate
                                  }  // 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";
                                    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";
                                      leaf pt {
                                        type uint32;
                                        description
                                          "pt";
                                      }

                                      leaf frequency {
                                        type uint32;
                                        description
                                          "frequency";
                                      }
                                    }  // list clock-rate
                                  }  // container rtp-voice

                                  container mdi {
                                    when
                                      "../type = 'policy-action-afmon-mdi-metric'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_MDI_METRIC'";
                                    }
                                    description
                                      "mdi";
                                    container ip-bit-rate {
                                      description
                                        "data rate in bps";
                                      leaf value {
                                        type uint32;
                                        description
                                          "value";
                                      }

                                      leaf unit {
                                        type Policy-param-unit-type;
                                        description
                                          "unit";
                                      }
                                    }  // 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";
                                    }
                                  }  // container mdi

                                  container mdi-rtp {
                                    when
                                      "../type = 'policy-action-afmon-mdi-rtp-metric'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_MDI_RTP_METRIC'";
                                    }
                                    description
                                      "mdi rtp";
                                    container ip-bit-rate {
                                      description
                                        "data rate in bps";
                                      leaf value {
                                        type uint32;
                                        description
                                          "value";
                                      }

                                      leaf unit {
                                        type Policy-param-unit-type;
                                        description
                                          "unit";
                                      }
                                    }  // 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";
                                    }
                                  }  // container mdi-rtp

                                  container fmm {
                                    when
                                      "../type = 'policy-action-afmon-fmm'" {
                                      description
                                        "../type = 'POLICY_ACTION_AFMON_FMM'";
                                    }
                                    description
                                      "fmm";
                                    leaf fmm-name {
                                      type string {
                                        length
                                          "0..33";
                                      }
                                      description
                                        "flow monitor name";
                                    }
                                  }  // container fmm

                                  container pbf {
                                    when
                                      "../type = 'policy-action-pbr-next-hop'" {
                                      description
                                        "../type = 'POLICY_ACTION_PBR_NEXTHOP'";
                                    }
                                    description
                                      "pbf";
                                    list action-pbf-info-array {
                                      description
                                        "action pbf info array";
                                      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";
                                      }
                                    }  // list action-pbf-info-array
                                  }  // container pbf

                                  container ipv4-nh {
                                    when
                                      "../type = 'policy-action-ipv4-nh'" {
                                      description
                                        "../type = 'POLICY_ACTION_IPV4_NH'";
                                    }
                                    description
                                      "ipv4 nh";
                                    list action-ipv4-nh-info-array {
                                      description
                                        "action ipv4 nh info array";
                                      leaf ipv4-nh-addr {
                                        type inet:ipv4-address;
                                        description
                                          "nh addr";
                                      }

                                      leaf vrf-name {
                                        type string;
                                        description
                                          "Vrf name";
                                      }
                                    }  // list 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";
                                    list action-ipv6-nh-info-array {
                                      description
                                        "action ipv6 nh info array";
                                      leaf ipv6-nh-addr {
                                        type inet:ipv6-address;
                                        description
                                          "IPV6 Address";
                                      }

                                      leaf vrf-name {
                                        type string;
                                        description
                                          "Vrf name";
                                      }
                                    }  // list 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";
                                  }
                                }  // container actp

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

                                leaf flags {
                                  type uint16;
                                  description
                                    "flags";
                                }
                              }  // list policy-action-info-st
                            }  // container act-infop

                            container nlri-infop {
                              description
                                "nlri info pointer";
                              container nlri {
                                description
                                  "nlri value";
                                leaf-list uint8_array {
                                  type uint8;
                                  description
                                    "uint8 array";
                                }
                              }  // container nlri
                            }  // 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
                        }  // 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
                    }  // 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
                }  // 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";
                  }

                  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";
                    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";
                    }
                  }  // list reference

                  list objects {
                    description
                      "Each object details";
                    leaf object-name {
                      type string {
                        length "0..64";
                      }
                      description
                        "Name of object (Policymap/Classmap)";
                    }
                  }  // list objects

                  list class-map-reference {
                    description
                      "Each Classmapdetails";
                    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";
                      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";
                      }
                    }  // list policy-map-reference
                  }  // list class-map-reference
                }  // 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";
                        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";
                          leaf pmap-name {
                            type string;
                            description
                              "pmap name";
                          }

                          list cmap-stats-arr {
                            description
                              "cmap stats arr";
                            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";
                            }
                          }  // list cmap-stats-arr
                        }  // list plmgr-vrf-stats
                      }  // 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";
                  }

                  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";
                    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";
                    }
                  }  // list reference

                  list objects {
                    description
                      "Each object details";
                    leaf object-name {
                      type string {
                        length "0..64";
                      }
                      description
                        "Name of object (Policymap/Classmap)";
                    }
                  }  // list objects

                  list class-map-reference {
                    description
                      "Each Classmapdetails";
                    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";
                      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";
                      }
                    }  // list policy-map-reference
                  }  // list class-map-reference
                }  // 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

        container summary {
          description
            "Summary of policy-maps and class-maps configured";
          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";
            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";
              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";
              }
            }  // list reference

            list objects {
              description
                "Each object details";
              leaf object-name {
                type string {
                  length "0..64";
                }
                description
                  "Name of object (Policymap/Classmap)";
              }
            }  // list objects

            list class-map-reference {
              description
                "Each Classmapdetails";
              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";
                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";
                }
              }  // list policy-map-reference
            }  // list class-map-reference
          }  // list class-maps

          list policy-maps {
            description
              "Summary of 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";
              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";
              }
            }  // list reference

            list objects {
              description
                "Each object details";
              leaf object-name {
                type string {
                  length "0..64";
                }
                description
                  "Name of object (Policymap/Classmap)";
              }
            }  // list objects

            list class-map-reference {
              description
                "Each Classmapdetails";
              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";
                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";
                }
              }  // list policy-map-reference
            }  // list class-map-reference
          }  // list policy-maps
        }  // container summary
      }  // container global
    }  // container policy-manager
  }  // module Cisco-IOS-XR-infra-policymgr-oper