module itm-state {

      namespace "urn:opendaylight:vpnservice:itm:op";

      prefix itm-state;

      import ietf-interfaces {
          prefix if;
      }

      import ietf-yang-types {
          prefix yang;
      }

      import ietf-inet-types {
          prefix inet;
          revision-date "2013-07-15";
      }
      import odl-interface {
          prefix odlif; revision-date "2015-03-31";
      }
    

      description "This YANG module defines operation part of the model.";

      revision "2015-07-01";

        /* Operational state */

    identity tep-type-base {
        description "Base TEP device type";
    }
    identity tep-type-internal {
        base tep-type-base;
        description "TEP type internal e.g. Compute OVS";
    }
    identity tep-type-external {
        base tep-type-base;
        description "TEP type external e.g. DC Gateway";
    }
    identity tep-type-hwvtep {
        base tep-type-base;
        description "TEP type Hwvtep e.g. TOR devices";
    }
    typedef tep-type {
        type identityref {
            base tep-type-base;
        }
        description "This type is used to refer to an TEP Device Type.";
    }
      container dpn-endpoints {

        list DPN-TEPs-info {

          key "DPN-ID";

          leaf DPN-ID {
                   type uint64;
          }
          leaf up {
             type boolean;
             config false;
          }

          /* Minimum 1 port. We may for now support only two ports */
          list tunnel-end-points {
                ordered-by user;
               key "portname VLAN-ID ip-address tunnel-type"; /* Multiple tunnels on the same physical port but on different VLAN can be supported */

                 leaf portname {
                     type string;
                     }
                 leaf VLAN-ID {
                     type uint16;
                     }
                 leaf ip-address {
                     type inet:ip-address;
                 }
                 leaf subnet-mask {
                     type inet:ip-prefix;
                 }
                 leaf gw-ip-address {
                          type inet:ip-address;
                 }
                 leaf transport-zone {
                          type string;
                 }
                 leaf interface-name {
                          type string;
                 }
                 leaf tunnel-type {
                      type identityref {
                          base odlif:tunnel-type-base;
                      }
                 }
           }

         }
      }


      container tunnel-list {
             list internal-tunnel {

               key  "source-DPN destination-DPN transport-type";

               leaf source-DPN {
                   type uint64;
               }

               leaf destination-DPN {
                   type uint64;
               }
               leaf transport-type {
                    type identityref {
                        base odlif:tunnel-type-base;
                    }
               }

               /* logical-group interface id */

               leaf tunnel-interface-name {
                    type string;
               }
             }
          }

      container external-tunnel-list {
             list external-tunnel {

               key  "source-device destination-device transport-type";

               leaf source-device {
                   type string; //dpnid or node-id
               }

               leaf destination-device {
                   type string; //dpn-id or node-id or ip
               }

               leaf transport-type {
                    type identityref {
                        base odlif:tunnel-type-base;
                    }
               }
               /* logical-group interface id */

               leaf tunnel-interface-name {
                    type string;
               }

             }
          }

        grouping tep-info-attributes {
            leaf tep-device-type {
                type identityref {
                    base tep-type-base;
                }
            }
            leaf tep-device-id {
                type string; //dpnid or node-id
            }
            leaf tep-ip {
                type inet:ip-address; //dpnid or node-id
            }
        }

      container tunnels_state {
        list state-tunnel-list {
            key  "tunnel-interface-name";
            leaf tunnel-interface-name {
                type string;
            }
            leaf tunnel-state {
                type boolean;
                config false;
            }
            container src-info {
                uses tep-info-attributes;
            }
            container dst-info {
                uses tep-info-attributes;
            }
            leaf transport-type {
                type identityref {
                    base odlif:tunnel-type-base;
                }
            }
        }
      }
          notification itm-tunnel-build-complete{
          }

}