module ietf-i2nsf-consumer-facing-interface {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-i2nsf-consumer-facing-interface";

    prefix capability-interface;

    import ietf-yang-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }

    organization
      "IETF I2NSF (Interface to Network Security Functions)
     Working Group";

    contact
      "WG Web: <http://tools.ietf.org/wg/i2nsf>
     WG List: <mailto:i2nsf@ietf.org>

     WG Chair: Adrian Farrel
     <mailto:Adrain@olddog.co.uk>

     WG Chair: Linda Dunbar
     <mailto:Linda.duhbar@huawei.com>

     Editor: Jaehoon Paul Jeong
     <mailto:pauljeong@skku.edu>";

    description
      "This module defines a YANG data module for consumer-facing
     interface to security controller.";

    revision "2017-07-03" {
      description "Initial revision";
      reference
        "draft-kumar-i2nsf-client-facing-interface-im-02";

    }


    container policy-instance {
      description
        "this describes the policy instances.";
      list policy-rule {
        key "policy-rule-id";
        description
          "This represents the policy-rule of a
          policy instance.";
        leaf policy-rule-id {
          type uint16;
          description "policy rule id.";
        }

        leaf name {
          type string;
          description
            "Name of the policy-rule.";
        }

        leaf date {
          type yang:date-and-time;
          description
            "The date when the rule was created.";
        }

        leaf source {
          type string;
          description
            "This references either end-point-group,
              threat-feed, or custom-list.";
        }

        leaf destination {
          type string;
          description
            "This references either end-point-group,
              threat-feed, or custom-list.";
        }

        leaf exception {
          type boolean;
          description
            "This describes whether an exception has
              occurred or not.";
        }

        leaf exception-detail {
          type string;
          description
            "This includes detailed information about
              source and destination of
              an exception.";
        }
      }  // list policy-rule

      list action {
        key "action-id";
        description
          "This represents the action of a policy-rule.";
        leaf action-id {
          type string;
          mandatory true;
          description
            "This represents the action-id of a policy-rule.";
        }

        leaf name {
          type string;
          description "The action name.";
        }

        leaf date {
          type yang:date-and-time;
          description
            "When the action was taken.";
        }

        leaf primary-action {
          type string;
          description
            "This includes actions such as permit,
              mirroring, rate-limit, ips, app-firewall,
              auth-session, and etc";
        }

        leaf secondary-action {
          type string;
          description
            "This includes optional actions such as
              logging, system logging and session logging.";
        }
      }  // list action

      list precedence {
        key "precedence-id";
        description
          "This describes whether there is a preceeding
            rule and causes problems.";
        leaf precedence-id {
          type string;
          mandatory true;
          description
            "This represent the precedence-id of
            a policy-rule.";
        }

        leaf rule-exist {
          type boolean;
          description
            "This determines whether there is a preceeding.";
        }
      }  // list precedence

      list event {
        key "event-id";
        description
          "This represents the security event of a
              policy-rule.";
        leaf event-id {
          type string;
          mandatory true;
          description
            "This represents the event-id.";
        }

        leaf security-event {
          type string;
          description
            "This references the security event in the
              threat-prevention .";
        }

        leaf threat-map {
          type string;
          description
            "This references the threat-map in the
              threat-prevention.";
        }

        leaf enable {
          type boolean;
          description
            "This determines whether the condition
              matches the security event or not.";
        }
      }  // list event

      list condition {
        key "condition-id";
        description
          "This represents the condition of a
              policy-rule.";
        leaf condition-id {
          type string;
          description
            "This represents the condition-id.";
        }

        list caller {
          key "caller-id";
          description
            "this represents the list of callers.";
          leaf caller-id {
            type uint16;
            description
              "the id of the caller.";
          }

          leaf caller-id-id {
            type string;
            description
              "The caller's number.";
          }

          leaf caller-country {
            type string;
            description
              "This determines the country of the caller.";
          }

          leaf caller-city {
            type string;
            description
              "This determines the city of the caller.";
          }
        }  // list caller

        list callee {
          key "callee-id";
          description
            "this represents the list of callees";
          leaf callee-id {
            type uint16;
            description
              "The id of the callee.";
          }

          leaf callee-id-id {
            type string;
            description
              "The callee's number.";
          }

          leaf callee-country {
            type string;
            description
              "This determines the country of the callee.";
          }

          leaf callee-city {
            type string;
            description
              "This determines the city of the callee.";
          }
        }  // list callee
      }  // list condition

      list policy-calendar {
        key "policy-calendar-id";
        description
          "this represents the policy calendar list.";
        leaf policy-calendar-id {
          type uint16;
          description
            "The id of the policy calendar.";
        }

        leaf name {
          type string;
          description
            "The name of the policy-calendar.";
        }

        leaf date {
          type yang:date-and-time;
          description
            "The date when this calender was
                created or last modified.";
        }

        leaf enforcement-type {
          type string;
          description
            "Whether the policy enforcement is
                admin-enforced, time-enforced, or
                event-enforced.";
        }

        leaf begin-time {
          type yang:date-and-time;
          description
            "The starting time for blocking
                suspicious calls.";
        }

        leaf end-time {
          type yang:date-and-time;
          description
            "The time when blocking ends.";
        }
      }  // list policy-calendar
    }  // container policy-instance
  }  // module ietf-i2nsf-consumer-facing-interface