module dell-base-udf {

    yang-version 1;

    namespace
      "http://www.dellemc.com/networking/os10/dell-base-udf";

    prefix base-udf;

    import dell-base-common {
      prefix base-cmn;
    }
    import ietf-inet-types {
      prefix inet;
    }

    organization "Dell EMC";

    contact "http://www.dell.com/support";

    description
      "This module contains a collection of YANG definitions
        for managing User Defined Filters (UDFs).

        Copyright (c) 2015-2019 by Dell EMC,
        All rights reserved.";

    revision "2018-08-17" {
      description
        "Fixing pyang IETF errors and adding documentation to the model.";
      reference
        "Network Platform Abstraction";

    }

    revision "2016-10-04" {
      description "Initial revision";
      reference
        "Network Platform Abstraction";

    }


    typedef udf-group-type {
      type enumeration {
        enum "GENERIC" {
          value 1;
          description "Generic UDF Group";
        }
        enum "HASH" {
          value 2;
          description "UDF Group for HASH";
        }
      }
      description
        "Enumeration of all possible UDF groups";
    }

    list udf-group {
      key "id";
      description
        "List of attributes of a UDF Group object.";
      leaf id {
        type base-cmn:base-obj-id-type;
        description
          "Unique ID generated upon Create request.
                         Subsequent Modify and Delete request requiries
                         this Group ID to be passed in.";
      }

      leaf type {
        type udf-group-type;
        mandatory true;
        description
          "Type of UDF Group to be created";
      }

      leaf length {
        type uint8;
        mandatory true;
        description
          "Length of bytes for the UDF objects in the group";
      }

      leaf-list udf-id-list {
        type base-cmn:base-obj-id-type;
        config false;
        description
          "List of UDF object IDs associated with this UDF Group";
      }

      leaf-list npu-id-list {
        type base-cmn:npu-id;
        description
          "Optional subset of NPUs on which this UDF Group needs to be installed.
                 If this atttribute is not specified then the UDF Group is installed on
                 all NPUs to which the UDF Group belongs.";
      }
    }  // list udf-group

    typedef udf-match-type {
      type enumeration {
        enum "NON_TUNNEL" {
          value 1;
          description
            "Match packets without tunnel encapsulation.";
        }
        enum "GRE_TUNNEL" {
          value 2;
          description
            "Match packets with GRE tunnel encapsulation.";
        }
      }
      description
        "Enumeration of all possible match rules";
    }

    list udf-match {
      key "id";
      description
        "List of attributes of an UDF Match object.";
      leaf id {
        type base-cmn:base-obj-id-type;
        description
          "Unique ID generated upon Create request.
                         Subsequent Modify and Delete request required
                         this Match ID to be passed in.";
      }

      leaf priority {
        type uint8;
        mandatory true;
        description "UDF Match priority.";
      }

      leaf type {
        type udf-match-type;
        mandatory true;
        description
          "Specify encapsulation type of packets this UDF Match
                         object is going to match";
      }

      container NON_TUNNEL_VALUE {
        when "../type = NON_TUNNEL";
        description
          "Set of attributes for non-tunnel case";
        leaf l2-type {
          type uint16;
          mandatory true;
          description
            "Protocol type of L2 header";
        }

        leaf l2-type-mask {
          type uint16;
          description
            "Protocol type mask of L2 header";
        }

        leaf l3-type {
          type uint8;
          mandatory true;
          description
            "Protocol type of L3 header";
        }

        leaf l3-type-mask {
          type uint8;
          description
            "Protocol type mask of L3 header";
        }
      }  // container NON_TUNNEL_VALUE

      container GRE_TUNNEL_VALUE {
        when "../type = GRE_TUNNEL";
        description
          "Set of attributes for GRE-tunnel case";
        leaf inner-type {
          type inet:ip-version;
          mandatory true;
          description
            "Type of inner IP header";
        }

        leaf outer-type {
          type inet:ip-version;
          description
            "Type of outer IP header";
        }
      }  // container GRE_TUNNEL_VALUE

      leaf-list npu-id-list {
        type base-cmn:npu-id;
        description
          "Optional subset of NPUs on which this UDF Match needs to be installed.
                 If this atttribute is not specified then the UDF Match is installed on
                 all NPUs to which the UDF Match belongs.";
      }
    }  // list udf-match

    typedef udf-base-type {
      type enumeration {
        enum "L2" {
          value 1;
          description
            "UDF offset base L2 header";
        }
        enum "L3" {
          value 2;
          description
            "UDF offset base L3 header";
        }
        enum "L4" {
          value 3;
          description
            "UDF offset base L4 header";
        }
      }
      description
        "Enumeration of all possible values of UDF base-offest";
    }

    list udf-obj {
      key "id";
      description
        "List of attributes of an UDF object.";
      leaf id {
        type base-cmn:base-obj-id-type;
        description
          "Unique ID generated upon Create request.
                         Subsequent Modify and Delete request required
                         this UDF ID to be passed in.";
      }

      leaf group-id {
        type base-cmn:base-obj-id-type;
        mandatory true;
        description
          "UDF Group ID associated with this UDF object";
      }

      leaf match-id {
        type base-cmn:base-obj-id-type;
        mandatory true;
        description
          "UDF Match ID associated with this UDF object";
      }

      leaf base {
        type udf-base-type;
        mandatory true;
        description "Base of the UDF";
      }

      leaf offset {
        type uint32;
        description
          "Offset from the base of the UDF";
      }

      leaf-list hash-mask {
        type uint8;
        description
          "Hash mask bytes to be used for the UDF Hash field";
      }

      leaf-list npu-id-list {
        type base-cmn:npu-id;
        description
          "Optional subset of NPUs on which this UDF Object needs to be installed.
                 If this atttribute is not specified then the UDF Object is installed on
                 all NPUs to which the UDF Object belongs.";
      }
    }  // list udf-obj
  }  // module dell-base-udf