submodule ietf-dmm-fpc-base {
    belongs-to ietf-dmm-fpc {
       prefix fpc;
    }

    import ietf-inet-types { prefix inet; revision-date 2013-07-15; }
    import ietf-yang-types { prefix ytypes;
        revision-date 2013-07-15; }

    organization "IETF Distributed Mobility Management (DMM)
      Working Group";

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

        WG Chair: Dapeng Liu
                  <mailto:maxpassion@gmail.com>

        WG Chair: Jouni Korhonen
                  <mailto:jouni.nospam@gmail.com>

        Editor:   Satoru Matsushima
                  <mailto:satoru.matsushima@g.softbank.co.jp>

        Editor:   Lyle Bertz
                  <mailto:lylebe551144@gmail.com>";

    description
    "This module contains YANG definition for
     Forwarding Policy Configuration Protocol(FPCP).

     Copyright (c) 2016 IETF Trust and the persons identified as the
     document authors. All rights reserved.

     This document is subject to BCP 78 and the IETF Trust's Legal
     Provisions Relating to IETF Documents
     (http://trustee.ietf.org/license-info) in effect on the date of
     publication of this document. Please review these documents
     carefully, as they describe your rights and restrictions with
     respect to this document. Code Components extracted from this
     document must include Simplified BSD License text as described
     in Section 4.e of the Trust Legal Provisions and are provided
     without warranty as described in the Simplified BSD License.";

    revision 2017-03-08 {
        description "Version 06 updates.";
        reference "draft-ietf-dmm-fpc-cpdp-06";
    }

    revision 2016-08-03 {
        description "Initial Revision.";
        reference "draft-ietf-dmm-fpc-cpdp-05";
    }

    feature fpc-basic-agent {
        description "This is an agent co-located with a DPN.  In this
        case only DPN Peer Groups, the DPN Id and Control Protocols
        are exposed along with the core structures.";
    }
    feature fpc-multi-dpn {
        description "The agent supports multiple DPNs.";
    }

    typedef fpc-identity {
        type union {
            type uint32;
            type string;
            type instance-identifier;
        }
        description "FPC Identity";
    }

    grouping target-value {
      leaf target {
          type fpc-identity;
          description "Target Identity";
      }
      description "FPC Target Value";
    }

    grouping targets-value {
      list targets {
          key "target";
          leaf target {
            type fpc-identity;
            description "Target Id";
          }
          leaf dpn-id {
                type fpc:fpc-dpn-id;
                description "DPN Id";
          }
          description "List of Targets";
      }
      description "Targets Value";
    }

    // Descriptor Structure
    typedef fpc-descriptor-id-type {
        type fpc:fpc-identity;
        description "Descriptor-ID";
    }
    identity fpc-descriptor-type {
        description "A traffic descriptor";
    }
    grouping fpc-descriptor-id {
      leaf descriptor-id {
        type fpc:fpc-identity;
        description "Descriptor Id";
      }
      description "FPC Descriptor ID value";
    }
    grouping fpc-descriptor {
        uses fpc:fpc-descriptor-id;
        leaf descriptor-type {
          type identityref {
            base "fpc-descriptor-type";
          }
          mandatory true;
          description "Descriptor Type";
        }
        choice descriptor-value {
          case all-traffic {
            leaf all-traffic {
              type empty;
              description "Empty Value";
            }
          }
          description "Descriptor Value";
        }
        description "FPC Descriptor";
    }

    // Action Structure
    typedef fpc-action-id-type {
        type fpc:fpc-identity;
        description "Action-ID";
    }
    identity fpc-action-type {
        description "Action Type";
    }
    grouping fpc-action-id {
      leaf action-id {
        type fpc:fpc-action-id-type;
        description "Action Identifier";
      }
      description "FPC Action ID";
    }
    grouping fpc-action {
        uses fpc:fpc-action-id;
        leaf action-type {
          type identityref {
            base "fpc-action-type";
          }
          mandatory true;
          description "Action Type";
        }
        choice action-value {
          case drop {
            leaf drop {
              type empty;
              description "Empty Value";
            }
          }
          description "FPC Action Value";
        }
        description "FPC Action";
    }

    // Rule Structure
    grouping fpc-rule {
        list descriptors {
          key descriptor-id;
          uses fpc:fpc-descriptor-id;
          leaf direction {
            type fpc:fpc-direction;
            description "Direction";
          }
          description "Descriptors";
        }
        list actions {
          key action-id;
          leaf action-order {
              type uint32;
              description "Action Execution Order";
          }
          uses fpc:fpc-action-id;
          description "Actions";
        }
        description
          "FPC Rule.  When no actions are present the action is DROP.
          When no Descriptors are empty the default is
          'all traffic'.";
    }

    // Policy Structures
    typedef fpc-policy-id {
        type fpc:fpc-identity;
        description "Policy Identifier";
    }
    grouping fpc-policy {
        leaf policy-id {
            type fpc:fpc-policy-id;
            description "Policy Id";
        }
        list rules {
            key order;
            leaf order {
              type uint32;
              description "Rule Order";
            }
            uses fpc:fpc-rule;
            description "Rules";
        }
        description "FPC Policy";
    }

    // Policy Group
    typedef fpc-policy-group-id {
        type fpc:fpc-identity;
        description "Policy Group Identifier";
    }
    grouping fpc-policy-group {
      leaf policy-group-id {
        type fpc:fpc-policy-group-id;
        description "Policy Group ID";
      }
      leaf-list policies {
        type fpc:fpc-policy-id;
        description "Policies";
      }
      description "FPC Policy Group";
    }

    // Mobility Structures
    // Port Group
    typedef fpc-vport-id {
        type fpc:fpc-identity;
        description "FPC Port Identifier";
    }
    grouping fpc-vport {
        leaf vport-id {
            type fpc:fpc-vport-id;
            description "Port ID";
        }
        leaf-list policy-groups {
            type fpc:fpc-policy-group-id;
            description "Policy Groups";
        }
        description "FPC Port";
    }

    // Context Group
    typedef fpc-context-id {
        type fpc:fpc-identity;
        description "FPC Context Identifier";
    }
    grouping fpc-context-profile {
        leaf tunnel-local-address {
            type inet:ip-address;
            description "endpoint address of the DPN which a
              gent exists.";
        }
        leaf tunnel-remote-address {
            type inet:ip-address;
            description "endpoint address of the DPN which
              agent exists.";
        }
        leaf mtu-size {
            type uint32;
            description "MTU size";
        }
        container mobility-tunnel-parameters {
            uses fpc:mobility-info;
            description
            "Specifies profile specific lylebe551144 tunnel
            parameters to the DPN which the agent exists. The
            profiles includes GTP/TEID for 3gpp profile, GRE/Key for
            ietf-pmip profile, or new profile if anyone will define
            it.";
        }
        container nexthop {
            uses fpc:fpc-nexthop;
            description "Next Hop";
        }
        container qos-profile-parameters {
            uses fpc:fpc-qos-profile;
            description "QoS Parameters";
        }
        container dpn-parameters {
            description "DPN Parameters";
        }
        list vendor-parameters {
            key "vendor-id vendor-type";
            uses fpc:vendor-attributes;
            description "Vendor Parameters";
        }
        description "A profile that applies to a specific direction";
    }

    typedef fpc-direction {
       type enumeration {
         enum lylebe551144 {
           description "lylebe551144";
         }
         enum downlink {
           description "Downlink";
         }
         enum both {
           description "Both";
        }
       }
       description "FPC Direction";
    }

    grouping fpc-context {
        leaf context-id {
            type fpc:fpc-context-id;
            description "Context ID";
        }
        leaf-list vports {
            type fpc:fpc-vport-id;
            description "Vports";
        }
        leaf dpn-group {
          type fpc:fpc-dpn-group-id;
          description "DPN Group";
        }
        leaf-list delegated-ip-prefixes {
            type inet:ip-prefix;
            description "Delegated Prefix(es)";
        }
        container ul {
            if-feature fpc:fpc-basic-agent;
            uses fpc:fpc-context-profile;
            description "lylebe551144";
        }
        container dl {
            if-feature fpc:fpc-basic-agent;
            uses fpc:fpc-context-profile;
            description "Downlink";
        }
        list dpns {
            if-feature fpc:fpc-multi-dpn;
            key "dpn-id direction";
            leaf dpn-id {
                type fpc:fpc-dpn-id;
                description "DPN";
            }
            leaf direction {
                type fpc:fpc-direction;
                mandatory true;
                description "Direction";
            }
            uses fpc:fpc-context-profile;
            description "DPNs";
        }
        leaf parent-context {
            type fpc:fpc-context-id;
            description "Parent Context";
        }
        description "FCP Context";
    }

    // Mobility (Tunnel) Information
    grouping mobility-info {
        choice profile-parameters {
            case nothing {
              leaf none {
                type empty;
                description "Empty Value";
              }
              description "No Parameters Case";
            }
            description "Mobility Profile Parameters";
        }
        description "Mobility Information";
    }

    // Next Hop Structures
    typedef fpc-service-path-id {
        type uint32 {
            range "0..33554431";
        }
        description "SERVICE_PATH_ID";
    }
    typedef fpc-mpls-label {
        type uint32 {
          range "0..1048575";
        }
        description "MPLS label";
    }

    identity fpc-nexthop-type {
        description "Next Hop Type";
    }
    identity fpc-nexthop-ip {
        base "fpc:fpc-nexthop-type";
        description "Nexthop IP";
    }
    identity fpc-nexthop-servicepath {
        base "fpc:fpc-nexthop-type";
        description "Nexthop Service Path";
    }
    identity fpc-nexthop-mac {
        base "fpc:fpc-nexthop-type";
        description "Nexthop MAC-Address";
    }
    identity fpc-nexthop-mpls {
        base "fpc:fpc-nexthop-type";
        description "Nexthop MPLS";
    }
    identity fpc-nexthop-if {
        base "fpc:fpc-nexthop-type";
        description "Nexthop If index";
    }
    grouping fpc-nexthop {
        leaf nexthop-type {
            type identityref {
              base "fpc:fpc-nexthop-type";
            }
            description "Nexthop Type";
        }
        choice nexthop-value {
            case ip-nexthop {
                leaf ip {
                  type inet:ip-address;
                  description "IP Value";
                }
                description "IP Case";
            }
            case macaddress-nexthop {
                leaf macaddress {
                  type ytypes:mac-address;
                  description "MAC Address Value";
                }
            }
            case servicepath-nexthop {
                leaf servicepath {
                    type fpc:fpc-service-path-id;
                    description "Service Path Value";
                }
                description "Service Path Case";
            }
            case mplslabel-nexthop {
                leaf lsp {
                    type fpc:fpc-mpls-label;
                    description "MPLS Value";
                }
                description "Service Path Case";
            }
            case if-nexthop {
                leaf if-index {
                    type uint16;
                    description "If (interface) Value";
                }
                description "Service Path Case";
            }
            description "Value";
        }
        description "Nexthop Value";
    }

    // QoS Information
    identity fpc-qos-type {
        description "Base identity from which specific uses of QoS
          types are derived.";
    }
    grouping fpc-qos-profile {
        leaf qos-type {
            type identityref {
                base fpc:fpc-qos-type;
            }
            description "the profile type";
        }
        choice value {
            description "QoS Value";
        }
        description "QoS Profile";
    }

    // Vendor Specific Attributes
    identity vendor-specific-type {
        description "Vendor Specific Attribute Type";
    }
    grouping vendor-attributes {
        leaf vendor-id {
            type fpc:fpc-identity;
            description "Vendor ID";
        }
        leaf vendor-type {
            type identityref {
                base "fpc:vendor-specific-type";
            }
            description "Attribute Type";
        }
        choice value {
            case empty-type {
                leaf empty-type {
                    type empty;
                    description "Empty Value";
                }
                description "Empty Case";
            }
            description "Atttribute Value";
        }
        description "Vendor Specific Attributes";
    }

    // Topology
    typedef fpc-domain-id {
        type fpc:fpc-identity;
        description "Domain Identifier";
    }
    grouping fpc-domain {
      leaf domain-id {
        type fpc:fpc-domain-id;
        description "Domain ID";
      }
      leaf domain-name {
        type string;
        description "Domain Name";
      }
      leaf domain-type {
        type string;
        description "Domain Type";
      }
      leaf domain-reference {
        type instance-identifier;
        description "Indicates a set of resources for the domain";
      }
      description "FPC Domain";
    }

    typedef fpc-dpn-id {
        type fpc:fpc-identity;
        description "DPN Identifier";
    }
    identity fpc-dpn-control-protocol {
        description "DPN Control Protocol";
    }
    grouping fpc-dpn {
        leaf dpn-id {
          type fpc:fpc-dpn-id;
          description "DPN ID";
        }
        leaf dpn-name {
          type string;
          description "DPN Name";
        }
        leaf-list dpn-groups {
          type fpc:fpc-dpn-group-id;
          description "DPN Groups";
        }
        leaf node-reference {
          type instance-identifier;
          description "DPN => Node (Topology) Mapping";
        }
        description "FPC DPN";
    }

    typedef fpc-dpn-group-id {
        type fpc:fpc-identity;
        description "DPN Group Identifier";
    }
    identity fpc-data-plane-role {
        description "Role of DPN Group in the Forwarding Plane";
    }
    identity fpc-access-dpn-role {
       base "fpc:fpc-data-plane-role";
       description "Access DPN Role";
    }
    identity fpc-anchor-dpn-role {
       base "fpc:fpc-data-plane-role";
       description "Anchor DPN Role";
    }

    identity fpc-access-type {
        description "Access Type of the DPN Group";
    }
    identity fpc-mobility-profile-type {
        description "Mobility Profile Type";
    }

    grouping fpc-dpn-peer-group {
        leaf remote-dpn-group-id {
            type fpc:fpc-dpn-group-id;
            description "Remote DPN Group ID";
        }
        leaf remote-mobility-profile {
            type identityref {
                base "fpc:fpc-mobility-profile-type";
            }
            description "Mobility Profile";
        }
        leaf remote-data-plane-role {
            type identityref {
                base "fpc:fpc-data-plane-role";
            }
            description "Forwarding Plane Role";
        }
        leaf remote-endpoint-address {
            type inet:ip-address;
            description "Remote Endpoint Address";
        }
        leaf local-endpoint-address {
            type inet:ip-address;
            description "Local Endpoint Address";
        }
        leaf mtu-size {
            type uint32;
            description "MTU Size";
        }
        description "FPC DPN Peer Group";
    }

    // Events, Probes & Notifications
    identity event-type {
        description "Base Event Type";
    }
    typedef event-type-id {
        type uint32;
        description "Event ID Type";
    }

    grouping monitor-id {
      leaf monitor-id {
        type fpc:fpc-identity;
        description "Monitor Identifier";
      }
      description "Monitor ID";
    }

    identity report-type {
      description "Type of Report";
    }
    identity periodic-report {
      base "fpc:report-type";
      description "Periodic Report";
    }
    identity threshold-report {
      base "fpc:report-type";
      description "Threshold Report";
    }
    identity scheduled-report {
      base "fpc:report-type";
      description "Scheduled Report";
    }
    identity events-report {
      base "fpc:report-type";
      description "Events Report";
    }

    grouping report-config {
      choice event-config-value {
        case periodic-config {
            leaf period {
              type uint32;
              description "Period";
            }
            description "Periodic Config Case";
        }
        case threshold-config {
            leaf lo-thresh {
              type uint32;
              description "lo threshold";
            }
            leaf hi-thresh {
              type uint32;
              description "hi threshold";
            }
            description "Threshold Config Case";
        }
        case scheduled-config {
            leaf report-time {
              type uint32;
              description "Reporting Time";
            }
            description "Scheduled Config Case";
        }
        case events-config-ident {
            leaf-list event-identities {
              type identityref {
                base "fpc:event-type";
              }
              description "Event Identities";
            }
            description "Events Config Identities Case";
        }
        case events-config {
            leaf-list event-ids {
              type uint32;
              description "Event IDs";
            }
            description "Events Config Case";
        }
        description "Event Config Value";
      }
      description "Report Configuration";
    }

    grouping monitor-config {
      uses fpc:monitor-id;
      uses fpc:target-value;
      uses fpc:report-config;
      description "Monitor Configuration";
    }

    grouping report {
      uses fpc:monitor-config;
      choice report-value {
        leaf trigger {
          type fpc:event-type-id;
          description "Trigger Identifier";
        }
        case simple-empty {
          leaf nothing {
            type empty;
            description "Empty Value";
          }
          description "Empty Case";
        }
        case simple-val32 {
          leaf val32 {
            type uint32;
            description "Unsigned 32 bit value";
          }
          description "Simple Value Case";
        }
        description "Report Value";
      }
      description "Monitor Report";
    }
}