module cisco-policy-filters {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:cisco-policy-filters";

    prefix cisco-filter;

    import cisco-semver {
      prefix cisco-semver;
    }
    import ietf-diffserv-classifier {
      prefix classifier;
    }
    import policy-attr {
      prefix policy-attr;
    }
    import policy-types {
      prefix policy-types;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com

     Editor:   Nazanin Magharei
               <mailto:nmaghare@cisco.com>";

    description
      "This module contains a collection of YANG definitions
     extending classmap module based on IETF-diffserv classifier.
     Copyright (c) 2016 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-07-01" {
      description
        "Establish semantic version baseline";
    }

    revision "2016-03-30" {
      description
        "Update description with copyright notice.";
    }

    revision "2015-04-27" {
      description "First revision";
      reference
        "TBD";

    }

    cisco-semver:module-version "1.0.0";

    augment /classifier:classifiers/classifier:classifier-entry {
      description
        "Augment class type to  Diffserv Classifier Entry";
      leaf classifier-entry-type {
        type identityref {
          base policy-types:class-type;
        }
        description "Type of the class-map";
      }
    }

    augment /classifier:classifiers/classifier:classifier-entry/classifier:filter-entry/classifier:filter-param {
      description
        "Augment Cisco policy filters to Diffserv Classifier Entry";
      case cos {
        if-feature policy-types:match-cos-support;
        container cos-cfgs {
          list cos-cfg {
            must 'cos-min <= cos-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal.";
            }
            key "cos-min cos-max";
            description
              "Match Type COS configuration";
            uses policy-attr:cos-cfg;
          }  // list cos-cfg
        }  // container cos-cfgs
      }  // case cos

      case cos-inner-filter {
        if-feature policy-types:match-cos-inner-support;
        container cos-inner-cfgs {
          description "Match Type COS-INNER";
          list cos-inner-cfg {
            must 'cos-min <= cos-min' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal.";
            }
            key "cos-min cos-max";
            description
              "Match Type COS-INNER configuration";
            uses policy-attr:cos-cfg;
          }  // list cos-inner-cfg
        }  // container cos-inner-cfgs
      }  // case cos-inner-filter

      case ipv4-acl-name-filter {
        if-feature policy-types:match-ipv4-acl-name-support;
        container ipv4-acl-name-cfgs {
          description
            "Match IPv4 Access-list name";
          list ipv4-acl-name-cfg {
            key "ip-acl-name";
            description
              "Match IPv4 Access-list name
             configuration";
            uses policy-attr:ip-acl-name-cfg;
          }  // list ipv4-acl-name-cfg
        }  // container ipv4-acl-name-cfgs
      }  // case ipv4-acl-name-filter

      case ipv6-acl-name-filter {
        if-feature policy-types:match-ipv6-acl-name-support;
        container ipv6-acl-name-cfgs {
          description
            "Match IPv6 Access-list name";
          list ipv6-acl-name-cfg {
            key "ip-acl-name";
            description
              "Match IPv6 Access-list name
             configuration";
            uses policy-attr:ip-acl-name-cfg;
          }  // list ipv6-acl-name-cfg
        }  // container ipv6-acl-name-cfgs
      }  // case ipv6-acl-name-filter

      case ipv4-acl-filter {
        if-feature policy-types:match-ipv4-acl-support;
        container ipv4-acl-cfgs {
          description
            "Match IPv4 Access-list number";
          list ipv4-acl-cfg {
            key "ip-acl";
            description
              "Match IPv4 Access-list number
             configuration";
            uses policy-attr:ip-acl-cfg;
          }  // list ipv4-acl-cfg
        }  // container ipv4-acl-cfgs
      }  // case ipv4-acl-filter

      case ipv6-acl-filter {
        if-feature policy-types:match-ipv6-acl-support;
        container ipv6-acl-cfgs {
          description
            "Match IPv6 Access-list number";
          list ipv6-acl-cfg {
            key "ip-acl";
            description
              "Match IPv6 Access-list number
             configuration";
            uses policy-attr:ip-acl-cfg;
          }  // list ipv6-acl-cfg
        }  // container ipv6-acl-cfgs
      }  // case ipv6-acl-filter

      case input-interface {
        if-feature policy-types:match-input-interface-support;
        container input-interface-cfgs {
          description
            "Match type Input interface";
          list input-interface-cfg {
            key "if-name";
            description
              "Match type Input interface
             configuration";
            uses policy-attr:input-interface-cfg;
          }  // list input-interface-cfg
        }  // container input-interface-cfgs
      }  // case input-interface

      case src-mac {
        if-feature policy-types:match-src-mac-support;
        container src-mac-cfgs {
          description
            "Match Type Source MAC Address";
          list src-mac-cfg {
            key "mac";
            description
              "Match Type Source MAC Address
             configuration";
            uses policy-attr:mac-cfg;
          }  // list src-mac-cfg
        }  // container src-mac-cfgs
      }  // case src-mac

      case dst-mac {
        if-feature policy-types:match-dst-mac-support;
        container dst-mac-cfgs {
          description
            "Match Type Destination MAC Address";
          list dst-mac-cfg {
            key "mac";
            description
              "Match Type Destination MAC Address
             configuration";
            uses policy-attr:mac-cfg;
          }  // list dst-mac-cfg
        }  // container dst-mac-cfgs
      }  // case dst-mac

      case protocol-name {
        if-feature policy-types:protocol-name-support;
        container protocol-name-cfgs {
          description
            "Match Type name-based protocol";
          list protocol-name-cfg {
            key "protocol-name";
            description
              "Match Type name-based protocol
             configuration";
            uses policy-attr:protocol-name-cfg;
          }  // list protocol-name-cfg
        }  // container protocol-name-cfgs
      }  // case protocol-name

      case mpls-exp-top {
        if-feature policy-types:match-mpls-exp-top-support;
        container mpls-exp-top-cfgs {
          description
            "Match MPLS experimental Topmost";
          list mpls-exp-top-cfg {
            must 'exp-min <= exp-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "exp-min exp-max";
            description
              "Match MPLS experimental Topmost
             configuration";
            uses policy-attr:mpls-exp-cfg;
          }  // list mpls-exp-top-cfg
        }  // container mpls-exp-top-cfgs
      }  // case mpls-exp-top

      case mpls-exp-imp {
        if-feature policy-types:match-mpls-exp-imp-support;
        container mpls-exp-imp-cfgs {
          description
            "Match MPLS experimental Imposition";
          list mpls-exp-imp-cfg {
            must 'exp-min <= exp-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "exp-min exp-max";
            description
              "Match MPLS experimental Imposition
             configuration";
            uses policy-attr:mpls-exp-cfg;
          }  // list mpls-exp-imp-cfg
        }  // container mpls-exp-imp-cfgs
      }  // case mpls-exp-imp

      case packet-length {
        if-feature policy-types:match-packet-length-support;
        container pkt-len-cfgs {
          description
            "Match Type Packet Length";
          list pkt-len-cfg {
            must
              'min-pkt-len <= max-pkt-len' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "min-pkt-len max-pkt-len";
            description
              "Match Type Packet Length
             configuration";
            uses policy-attr:pkt-len-cfg;
          }  // list pkt-len-cfg
        }  // container pkt-len-cfgs
      }  // case packet-length

      case prec {
        if-feature policy-types:match-prec-support;
        container prec {
          description
            "Match Type Precedence in
           IPv4 and IPv6 packets";
          choice prec-par {
            description
              "Match Type Precedence in
             IPv4 and IPv6 packets based on value or attribute";
            container prec-val-cfgs {
              description
                "Match Type Precedence
                 based on value";
              list prec-val-cfg {
                key "prec-val";
                description
                  "Match Type Precedence
                   based on value configuration";
                uses policy-attr:prec-val-cfg;
              }  // list prec-val-cfg
            }  // container prec-val-cfgs
            container prec-attr-cfgs {
              description
                "Match Type Precedence
                 based on attribute";
              list prec-attr-cfg {
                key "prec-attr";
                description
                  "Match Type Precedence
                   based on attribute configuration";
                uses policy-attr:prec-attr-cfg;
              }  // list prec-attr-cfg
            }  // container prec-attr-cfgs
          }  // choice prec-par
        }  // container prec
      }  // case prec

      case qos-group {
        if-feature policy-types:match-qos-group-support;
        container qos-group-cfgs {
          description "Match Type QoS Group";
          list qos-group-cfg {
            must
              'qos-group-min<=qos-group-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "qos-group-min qos-group-max";
            description
              "Match Type QoS Group configuration";
            uses policy-attr:qos-group-cfg;
          }  // list qos-group-cfg
        }  // container qos-group-cfgs
      }  // case qos-group

      case vlan {
        if-feature policy-types:match-vlan-support;
        container vlan-cfgs {
          description "Match Type VLAN";
          list vlan-cfg {
            must 'vlan-min<=vlan-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "vlan-min vlan-max";
            description
              "Match Type VLAN configuration";
            uses policy-attr:vlan-cfg;
          }  // list vlan-cfg
        }  // container vlan-cfgs
      }  // case vlan

      case vlan-inner {
        if-feature policy-types:match-vlan-inner-support;
        container vlan-inner-cfgs {
          description
            "Match Type Inner VLAN";
          list vlan-inner-cfg {
            must 'vlan-min<=vlan-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "vlan-min vlan-max";
            description
              "Match Type Inner VLAN
             configuration";
            uses policy-attr:vlan-cfg;
          }  // list vlan-inner-cfg
        }  // container vlan-inner-cfgs
      }  // case vlan-inner

      case atm-clp {
        if-feature policy-types:match-atm-clp-support;
        container atm-clp-cfg {
          description
            "Match ATM Cell Loss Priority (CLP)";
          uses policy-attr:atm-clp-cfg;
        }  // container atm-clp-cfg
      }  // case atm-clp

      case atm-vci {
        if-feature policy-types:match-atm-vci-support;
        container atm-vci-cfgs {
          description
            "Match ATM Virtual Channel Identifier
           (VCI)";
          list atm-vci-cfg {
            must 'atm-vci-min<=atm-vci-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "atm-vci-min atm-vci-max";
            description
              "Match ATM Virtual Channel
             Identifier (VCI) configuration";
            uses policy-attr:atm-vci-cfg;
          }  // list atm-vci-cfg
        }  // container atm-vci-cfgs
      }  // case atm-vci

      case dei {
        if-feature policy-types:match-dei-support;
        container dei-cfg {
          description
            "Match Type DEI Bit configuration";
          uses policy-attr:dei-cfg;
        }  // container dei-cfg
      }  // case dei

      case dei-inner {
        if-feature policy-types:match-dei-inner-support;
        container dei-inner-cfg {
          description
            "Match Type Inner DEI Bit";
          uses policy-attr:dei-cfg;
        }  // container dei-inner-cfg
      }  // case dei-inner

      case flow-ip {
        if-feature policy-types:match-flow-ip-support;
        container flow-ip-cfg {
          description "Match Type flow";
          uses policy-attr:flow-cfg;
        }  // container flow-ip-cfg
      }  // case flow-ip
      container flow-record-cfg {
        description
          "Match Type flow Record Name";
        uses policy-attr:flow-record-cfg;
      }  // container flow-record-cfg

      case fr-de {
        if-feature policy-types:match-fr-de-support;
        container fr-de-cfg {
          description "Match Frame Relay DE";
          uses policy-attr:fr-de-cfg;
        }  // container fr-de-cfg
      }  // case fr-de

      case fr-dlci {
        if-feature policy-types:match-fr-dlci-support;
        container fr-dlci-cfgs {
          description
            "Match Frame Relay DLCI";
          list fr-dlci-cfg {
            must 'dlci-min<=dlci-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "dlci-min dlci-max";
            description
              "Match Frame Relay DLCI
             configuration";
            uses policy-attr:fr-dlci-cfg;
          }  // list fr-dlci-cfg
        }  // container fr-dlci-cfgs
      }  // case fr-dlci

      case wlan-user-priority {
        if-feature policy-types:match-wlan-user-priority-support;
        container wlan-user-priority-cfgs {
          description
            "Match Type Wlan User Priority";
          list wlan-user-priority-cfg {
            must
              'wlan-prio-min<=wlan-prio-max' {
              description
                "The configuration is a range,
               for individual values min and max should
               be equal. ";
            }
            key "wlan-prio-min wlan-prio-max";
            description
              "Match Type Wlan User Priority
             configuration";
            uses policy-attr:wlan-user-priority-cfg;
          }  // list wlan-user-priority-cfg
        }  // container wlan-user-priority-cfgs
      }  // case wlan-user-priority

      case discard-class {
        if-feature policy-types:match-discard-class-support;
        container discard-class-cfgs {
          description
            "Match Type Discard Class";
          list discard-class-cfg {
            key "discard-class";
            description
              "Match Type Discard Class
             configuration";
            uses policy-attr:discard-class-cfg;
          }  // list discard-class-cfg
        }  // container discard-class-cfgs
      }  // case discard-class

      case class-map {
        if-feature policy-types:match-class-map-support;
        container class-map-cfgs {
          description
            "Match Type cls-map Name";
          list class-map-cfg {
            key "class-map-name";
            description
              "Match Type cls-map Name
             configuration";
            uses policy-attr:class-map-cfg;
          }  // list class-map-cfg
        }  // container class-map-cfgs
      }  // case class-map

      case metadata {
        if-feature policy-types:match-metadata-support;
        container metadata-cfg {
          description "Match Type Metadata";
          uses policy-attr:metadata-cfg;
        }  // container metadata-cfg
      }  // case metadata

      case application {
        if-feature policy-types:match-application-support;
        container application-cfgs {
          description
            "Match Type Application";
          list application-cfg {
            key "application-name application-cfg";
            description
              "Match Type Application
             configuration";
            uses policy-attr:application-cfg;
          }  // list application-cfg
        }  // container application-cfgs
      }  // case application

      case security-group {
        if-feature policy-types:match-security-group-support;
        container security-group {
          description
            "Match Type security tag.";
          choice group-par {
            description
              "Match Type security tag
             based on tag or id.";
            container security-group-name-cfgs {
              description
                "Match Type security
                 group based on name";
              list security-group-name-cfg {
                key "src-dst security-name";
                description
                  "Match Type security
                   group based on name configuration";
                uses policy-attr:security-group-name-cfg;
              }  // list security-group-name-cfg
            }  // container security-group-name-cfgs
            container security-group-tag-cfgs {
              description
                "Match Type security
                 group based on tag";
              list security-group-tag-cfg {
                key "id";
                description
                  "Match Type security
                   group based on tag configuration";
                uses policy-attr:security-group-tag-cfg;
              }  // list security-group-tag-cfg
            }  // container security-group-tag-cfgs
          }  // choice group-par
        }  // container security-group
      }  // case security-group

      case ip-rtp {
        if-feature policy-types:match-ip-rtp-support;
        container ip-rtp-cfgs {
          description "Match Type IP RTP.";
          list ip-rtp-cfg {
            must
              'starting-port-number<=port-range' {
              description
                "The configuration is lower
               bound and range of UDP ports.";
            }
            key "starting-port-number port-range";
            description
              "Match Type IP RTP configuration.";
            uses policy-attr:ip-rtp-cfg;
          }  // list ip-rtp-cfg
        }  // container ip-rtp-cfgs
      }  // case ip-rtp

      case vpls {
        if-feature policy-types:match-vpls-support;
        container vpls-cfg {
          description "Match Type VPLS.";
          uses policy-attr:vpls-cfg;
        }  // container vpls-cfg
      }  // case vpls
    }
  }  // module cisco-policy-filters