module yrt-ietf-te-topology {
 yang-version 1;
 namespace "urn:ietf:params:xml:ns:yang:yrt-ietf-te-topology";
 // replace with IANA namespace when assigned

 prefix "tet";

 import yrt-ietf-inet-types {
   prefix "inet";
 }

 import yrt-ietf-schedule {
   prefix "sch";
 }

 import yrt-ietf-te-types {
   prefix "te-types";
 }

 import yrt-ietf-network {
   prefix "nw";
 }

 import yrt-network-topology {
   prefix "nt";
 }

 organization
   "Traffic Engineering Architecture and Signaling (TEAS)
    Working Group";

 contact
   "WG Web:   <http://tools.ietf.org/wg/teas/>
    WG List:  <mailto:teas@ietf.org>
    WG Chair: Lou Berger
              <mailto:lberger@labn.net>
    WG Chair: Vishnu Pavan Beeram
              <mailto:vbeeram@juniper.net>
    Editor:   Xufeng Liu
              <mailto:xliu@kuatrotech.com>
    Editor:   Igor Bryskin
              <mailto:Igor.Bryskin@huawei.com>
    Editor:   Vishnu Pavan Beeram
              <mailto:vbeeram@juniper.net>
    Editor:   Tarek Saad
              <mailto:tsaad@cisco.com>
    Editor:   Himanshu Shah
              <mailto:hshah@ciena.com>
    Editor:   Oscar Gonzalez De Dios
              <mailto:oscar.gonzalezdedios@telefonica.com>";

 description "TE topology model";

 revision "2016-03-17" {
   description "Initial revision";
   reference "TBD";
 }

 /*
  * Features
  */

 feature configuration-schedule {
   description
     "This feature indicates that the system supports
      configuration scheduling.";
 }

 feature te-topology-hierarchy {
   description
     "This feature indicates that the system allows underlay
      and/or overlay TE topology hierarchy.";
 }

 feature te-performance-metric {
   description
     "This feature indicates that the system supports
      TE performance metric defined in
      RFC7471: OSPF Traffic Engineering (TE) Metric Extensions.";
 }

 feature template {
   description
     "This feature indicates that the system supports
      template configuration.";
 }

 /*
  * Typedefs
  */
 typedef performance-metric-normality {
   type enumeration {
     enum "unknown" {
       value 0;
       description
         "Unknown.";
     }
     enum "normal" {
       value 1;
       description
         "Normal.";
     }
     enum "abnormal" {
       value 2;
       description
         "Abnormal. The anomalous bit is set.";
     }
   }
   description
     "Indicates whether a performance metric is normal, abnormal, or
      unknown.";
   reference
     "RFC7471: OSPF Traffic Engineering (TE) Metric Extensions.";
 }

 typedef te-admin-status {
   type enumeration {
     enum up {
       description
         "Enabled.";
     }
     enum down {
       description
         "Disabled.";
     }
     enum testing {
       description
         "In some test mode.";
     }
     enum preparing-maintenance {
       description
         "Resource is disabled in the control plane to prepare for
          graceful shutdown for maintenance purposes.";
       reference
         "RFC5817: Graceful Shutdown in MPLS and Generalized MPLS
          Traffic Engineering Networks";
     }
     enum maintenance {
       description
         "Resource is disabled in the data plane for maintenance
          purposes.";
     }
   }
   description
     "Defines a type representing the administrative status of
      a TE resource.";
 }
 typedef te-global-id {
   type uint32;
   description
     "An identifier to uniquely identify an operator, which can be
      either a provider or a client.
      The definition of this type is taken from RFC6370 and RFC5003.
      This attribute type is used solely to provide a globally
      unique context for TE topologies.";
 }

 typedef te-link-access-type {
   type enumeration {
     enum point-to-point {
       description
         "The link is point-to-point.";
     }
     enum multi-access {
       description
         "The link is multi-access, including broacast and NBMA.";
     }
   }
   description
     "Defines a type representing the access type of a TE link.";
   reference
     "RFC3630: Traffic Engineering (TE) Extensions to OSPF
      Version 2.";
 }

 typedef te-node-id {
   type inet:ip-address;
   description
     "An identifier for a node in a topology.
      The identifier is represented as an IPv4 or IPv6 address.
      This attribute is mapped to Router ID in
      RFC3630, RFC5329, RFC5305, and RFC 6119.";
 }

 typedef te-oper-status {
   type enumeration {
     enum up {
       description
       "Operational up.";
     }
     enum down {
       description
       "Operational down.";
     }
     enum testing {
       description
       "In some test mode.";
     }
     enum unknown {
       description
       "Status cannot be determined for some reason.";
     }
     enum preparing-maintenance {
       description
         "Resource is disabled in the control plane to prepare for
          graceful shutdown for maintenance purposes.";
       reference
         "RFC5817: Graceful Shutdown in MPLS and Generalized MPLS
          Traffic Engineering Networks";
     }
     enum maintenance {
       description
         "Resource is disabled in the data plane for maintenance
          purposes.";
     }
   }
   description
     "Defines a type representing the operational status of
      a TE resource.";
 }

 typedef te-recovery-status {
   type enumeration {
     enum normal {
       description
         "Both the recovery and working spans are fully
          allocated and active, data traffic is being
          transported over (or selected from) the working
          span, and no trigger events are reported.";
     }
     enum recovery-started {
       description
         "The recovery action has been started, but not completed.";
     }
     enum recovery-succeeded {
       description
         "The recovery action has succeeded. The working span has
          reported a failure/degrade condition and the user traffic
          is being transported (or selected) on the recovery span.";
     }
     enum recovery-failed {
       description
         "The recovery action has failed.";
     }
     enum reversion-started {
       description
         "The reversion has started.";
     }
     enum reversion-failed {
       description
         "The reversion has failed.";
     }
     enum recovery-unavailable {
       description
         "The recovery is unavailable -- either as a result of an
          operator Lockout command or a failure condition detected
          on the recovery span.";
     }
     enum recovery-admin {
       description
         "The operator has issued a command switching the user
          traffic to the recovery span.";
     }
     enum wait-to-restore {
       description
         "The recovery domain is recovering from a failuer/degrade
          condition on the working span that is being controlled by
          the Wait-to-Restore (WTR) timer.";
     }
   }
 }

 typedef te-template-name {
   type string {
     pattern '/?([a-zA-Z0-9\-_.]+)(/[a-zA-Z0-9\-_.]+)*';
   }
 }

 typedef te-topology-event-type {
   type enumeration {
     enum "add" {
       value 0;
     }
     enum "remove" {
       value 1;
     }
     enum "update" {
       value 2;
     }
   }
 } // te-topology-event-type
 typedef te-topology-id {
   type string {
     pattern '/?([a-zA-Z0-9\-_.]+)(/[a-zA-Z0-9\-_.]+)*';
   }
 }

 typedef te-tp-id {
   type union {
     type uint32;          // Unnumbered
     type inet:ip-address; // IPv4 or IPv6 address
   }
 }

 /*
  * Identities
  */

 /*
  * Groupings
  */
 grouping information-source-attributes {
   leaf information-source {
     type enumeration {
       enum "unknown";
       enum "locally-configured";
       enum "ospfv2";
       enum "ospfv3";
       enum "isis";
       enum "system-processed";
       enum "other";
     }
   }
   container information-source-state {
     leaf credibility-preference {
       type uint16;
     }
     container topology {
       uses te-topology-ref;
     } // topology
     leaf routing-instance {
       type string;
     } // routing-information
   }
 } // information-source-attributes

 grouping performance-metric-attributes {
   leaf unidirectional-delay {
     type uint32 {
       range 0..16777215;
     }
   }
   leaf unidirectional-min-delay {
     type uint32 {
       range 0..16777215;
     }
   }
   leaf unidirectional-max-delay {
     type uint32 {
       range 0..16777215;
     }
   }
   leaf unidirectional-delay-variation {
     type uint32 {
       range 0..16777215;
     }
   }
   leaf unidirectional-packet-loss {
     type decimal64 {
       fraction-digits 6;
       range "0 .. 50.331642";
     }
   }
   leaf unidirectional-residual-bandwidth {
     type decimal64 {
       fraction-digits 2;
     }
   }
   leaf unidirectional-available-bandwidth {
     type decimal64 {
       fraction-digits 2;
     }
   }
   leaf unidirectional-utilized-bandwidth {
     type decimal64 {
       fraction-digits 2;
     }
   }
 } // performance-metric-attributes
 grouping performance-metric-normality-attributes {
   leaf unidirectional-delay {
     type performance-metric-normality;
   }
   leaf unidirectional-min-delay {
     type performance-metric-normality;
   }
   leaf unidirectional-max-delay {
     type performance-metric-normality;
   }
   leaf unidirectional-delay-variation {
     type performance-metric-normality;
   }
   leaf unidirectional-packet-loss {
     type performance-metric-normality;
   }
   leaf unidirectional-residual-bandwidth {
     type performance-metric-normality;
   }
   leaf unidirectional-available-bandwidth {
     type performance-metric-normality;
   }
   leaf unidirectional-utilized-bandwidth {
     type performance-metric-normality;
   }
 } // performance-metric-normality-attributes

 grouping performance-metric-throttle-container {
   container performance-metric-throttle {
     leaf unidirectional-delay-offset {
       type uint32 {
         range 0..16777215;
       }
     }
     leaf measure-interval {
       type uint32;
       default 30;
     }
     leaf advertisement-interval {
       type uint32;
     }
     leaf suppression-interval {
       type uint32 {
         range "1 .. max";
       }
       default 120;
     }
     container threshold-out {
       uses performance-metric-attributes;
     }
     container threshold-in {
       uses performance-metric-attributes;
     }
     container threshold-accelerated-advertisement {
       uses performance-metric-attributes;
     }
   }
 } // performance-metric-throttle-container

 grouping te-link-augment {
   container te {
     presence "TE support.";
     container config {
       uses te-link-config;
     } // config
     container state {
       config false;
       uses te-link-config;
       uses te-link-state-derived;
     } // state
   } // te
 } // te-link-augment

 grouping te-link-config {
   choice bundle-stack-level {
     case bundle {
       container bundled-links {
         list bundled-link {
           key "sequence";
           leaf sequence {
             type uint32;
           }
           leaf src-tp-ref {
             type leafref {
               path "../../../../../../nw:node[nw:node-id = "
                 + "current()/../../../../../nt:source/"
                 + "nt:source-node]/"
                 + "nt:t-point/nt:tp-id";
               require-instance true;
             }
           }
           leaf des-tp-ref {
             type leafref {
               path "../../../../../../nw:node[nw:node-id = "
                 + "current()/../../../../../nt:destination/"
                 + "nt:dest-node]/"
                 + "nt:t-point/nt:tp-id";
               require-instance true;
             }
           }
         } // list bundled-link
       }
     }
     case component {
       container component-links {
         list component-link {
           key "sequence";
           leaf sequence {
             type uint32;
           }
           leaf src-interface-ref {
             type string;
           }
           leaf des-interface-ref {
             type string;
           }
         }
       }
     }
   } // bundle-stack-level

   leaf-list te-link-template {
     if-feature template;
     type leafref {
       path "../../../../../te/templates/link-template/name";
     }
   }
   uses te-link-config-attributes;
 } // te-link-config

 grouping te-link-config-attributes {
   container te-link-attributes {
     uses sch:schedules;
     leaf access-type {
       type te-link-access-type;
     }
     leaf is-abstract {
       type empty;
     }
     leaf name {
       type string;
     }
     container underlay {
       presence
         "Indicates the underlay exists for this link.";
       uses te-link-underlay-attributes;
     } // underlay
     leaf admin-status {
       type te-admin-status;
       description
         "The administrative state of the link.";
     }

     uses performance-metric-throttle-container;
     uses te-link-info-attributes;
   } // te-link-attributes
 } // te-link-config-attributes

 grouping te-link-info-attributes {
   leaf link-index {
     type uint64;
   }
   leaf administrative-group {
     type te-types:admin-groups;
   }
   leaf max-link-bandwidth {
     type decimal64 {
       fraction-digits 2;
     }
   }
   leaf max-resv-link-bandwidth {
     type decimal64 {
       fraction-digits 2;
     }
   }
   list unreserved-bandwidth {
     key "priority";
     max-elements "8";
     leaf priority {
       type uint8 {
         range "0..7";
       }
     }
     leaf bandwidth {
       type decimal64 {
         fraction-digits 2;
       }
     }
   }
   leaf te-default-metric {
     type uint32;
   }
   container performance-metric {
     container measurement {
       uses performance-metric-attributes;
     }
     container normality
     {
       uses performance-metric-normality-attributes;
     }
   }
   leaf link-protection-type {
     type enumeration {
       enum "unprotected";
       enum "extra-traffic";
       enum "shared";
       enum "1-for-1";
       enum "1-plus-1";
       enum "enhanced";
     }
   }
   list interface-switching-capability {
     key "switching-capability";
     leaf switching-capability {
       type identityref {
         base te-types:switching-capabilities;
       }
     }
     leaf encoding {
       type identityref {
         base te-types:lsp-encoding-types;
       }
     }
     list max-lsp-bandwidth {
       key "priority";
       max-elements "8";
       leaf priority {
         type uint8 {
           range "0..7";
         }
       }
       leaf bandwidth {
         type decimal64 {
           fraction-digits 2;
         }
       }
     }
     container time-division-multiplex-capable {
       leaf minimum-lsp-bandwidth {
         type decimal64 {
           fraction-digits 2;
         }
       }
       leaf indication {
         type enumeration {
           enum "standard";
           enum "arbitrary";
         }
       }
     }
     list interface-adjustment-capability {
       key "upper-sc";
       leaf upper-sc {
         type identityref {
           base te-types:switching-capabilities;
         }
       }
       leaf upper-encoding {
         type identityref {
           base te-types:lsp-encoding-types;
         }
       }
       list max-lsp-bandwidth {
         key "priority";
         max-elements "8";
         leaf priority {
           type uint8 {
             range "0..7";
           }
           description "Priority.";
         }
         leaf bandwidth {
           type decimal64 {
             fraction-digits 2;
           }
         }
       }
     } // interface-adjustment-capability
   } // interface-switching-capability
   container te-srlgs {
     leaf-list values {
       type te-types:srlg;
     }
   }
 } // te-link-info-attributes

 grouping te-link-state-derived {
   leaf oper-status {
     type te-oper-status;
   }
   uses information-source-attributes;
   list alt-information-sources {
     key "information-source";
     uses information-source-attributes;
     uses te-link-info-attributes;
   }
   container recovery {
     leaf restoration-status {
       type te-recovery-status;
     }
     leaf protection-status {
       type te-recovery-status;
     }
   }
   container underlay {
     uses te-link-state-underlay-attributes;
   }
 } // te-link-state-derived
 grouping te-link-state-underlay-attributes {
   leaf dynamic {
     type boolean;
   }
   leaf committed {
     type boolean;
   }
 } // te-link-state-underlay-attributes

 grouping te-link-underlay-attributes {
   container underlay-primary-path {
     uses te-topology-ref;
     list path-element {
       key "path-element-id";
       leaf path-element-id {
         type uint32;
       }
       uses te-path-element;
     }
   } // underlay-primary-path
   list underlay-backup-path {
     key "index";
     leaf index {
       type uint32;
     }
     uses te-topology-ref;
     list path-element {
       key "path-element-id";
       leaf path-element-id {
         type uint32;
       }
       uses te-path-element;
     }
   } // underlay-backup-path
   leaf underlay-protection-type {
     type uint16;
   }
   container underlay-trail-src {
     uses nt:tp-ref;
   }
   container underlay-trail-des {
     uses nt:tp-ref;
   }
 } // te-link-underlay-attributes

 grouping te-node-augment {
   container te {
     presence "TE support.";
     leaf te-node-id {
       type te-node-id;
     }

     container config {
       description
         "Configuration data.";
       uses te-node-config;
     } // config
     container state {
       config false;
       description
         "Operational state data.";

       uses te-node-config;
       uses te-node-state-derived;
     } // state

     list tunnel-termination-point {
       key "tunnel-tp-id";
       leaf tunnel-tp-id {
         type binary;
       }
       container config {
         uses te-node-tunnel-termination-capability;
       }

       container state {
         config false;
         uses te-node-tunnel-termination-capability;
         leaf switching-capability {
           type identityref {
             base te-types:switching-capabilities;
           }
         }
         leaf encoding {
           type identityref {
             base te-types:lsp-encoding-types;
           }
         }
       } // state

     } // tunnel-termination-point
   } // te
 } // te-node-augment

 grouping te-node-config {
   leaf-list te-node-template {
     if-feature template;
     type leafref {
       path "../../../../../te/templates/node-template/name";
     }
   }
   uses te-node-config-attributes;
 } // te-node-config

 grouping te-node-config-attributes {
   container te-node-attributes {
     uses sch:schedules;
     leaf admin-status {
       type te-admin-status;
       description
         "The administrative state of the link.";
     }
     uses te-node-connectivity-matrix;
     uses te-node-info-attributes;
   } // te-node-attributes
 } // te-node-config-attributes

 grouping te-node-config-attributes-notification {
   container te-node-attributes {
     uses sch:schedules;
     leaf admin-status {
       type te-admin-status;
     }
     uses te-node-connectivity-matrix-abs;
     uses te-node-info-attributes;
   } // te-node-attributes
 } // te-node-config-attributes-notification

 grouping te-node-config-attributes-template {
   container te-node-attributes {
     uses sch:schedules;
     leaf admin-status {
       type te-admin-status;
     }
     uses te-node-info-attributes;
   } // te-node-attributes
 } // te-node-config-attributes-template

 grouping te-node-connectivity-matrix {
   list connectivity-matrix {
     key "id";
     leaf id {
       type uint32;
     }
     container from {
       leaf tp-ref {
         type leafref {
           path "../../../../../../nt:t-point/nt:tp-id";
         }
       }
     }
     container to {
       leaf tp-ref {
         type leafref {
           path "../../../../../../nt:t-point/nt:tp-id";
         }
       }
     }
     leaf is-allowed {
       type boolean;
     }
   }
 } // te-node-connectivity-matrix

 grouping te-node-connectivity-matrix-abs {
   list connectivity-matrix {
     key "id";
     leaf id {
       type uint32;
     }
     container from {
       uses nt:tp-ref;
     }
     container to {
       uses nt:tp-ref;
     }
     leaf is-allowed {
       type boolean;
     }
   }
 } // te-node-connectivity-matrix-abs

 grouping te-node-info-attributes {
   leaf domain-id {
     type uint32;
   }
   leaf is-abstract {
     type empty;
   }
   leaf name {
     type inet:domain-name;
   }
   leaf-list signaling-address {
     type inet:ip-address;
   }
   container underlay-topology {
     if-feature te-topology-hierarchy;
     uses te-topology-ref;
   }
 } // te-node-info-attributes

 grouping te-node-state-derived {
   description "Node state attributes in a TE topology.";
   leaf oper-status {
     type te-oper-status;
   }
   leaf is-multi-access-dr {
     type empty;
   }
   uses information-source-attributes;
   list alt-information-sources {
     key "information-source";
     uses information-source-attributes;
     uses te-node-connectivity-matrix;
     uses te-node-info-attributes;
   }
 } // te-node-state-derived

 grouping te-node-state-derived-notification {
   description "Node state attributes in a TE topology.";
   leaf oper-status {
     type te-oper-status;
   }
   leaf is-multi-access-dr {
     type empty;
   }
   uses information-source-attributes;
   list alt-information-sources {
     key "information-source";
     uses information-source-attributes;
     uses te-node-connectivity-matrix-abs;
     uses te-node-info-attributes;
   }
 } // te-node-state-derived-notification

 grouping te-node-tunnel-termination-capability {
   list termination-capability {
     key "link-tp";
     leaf link-tp {
       type leafref {
         path "../../../../../nt:t-point/nt:tp-id";
       }
     }
   } // termination-capability
 } // te-node-tunnel-termination-capability

 grouping te-path-element {
   uses te-types:explicit-route-subobject;
 } // te-path-element

 grouping te-termination-point-augment {

   container te {
     presence "TE support.";

     leaf te-tp-id {
       type te-tp-id;
       mandatory true;
     }

     container config {
       uses te-termination-point-config;
     } // config
     container state {
       config false;
       uses te-termination-point-config;
     } // state
   } // te
 } // te-termination-point-augment

 grouping te-termination-point-config {
   uses sch:schedules;
 } // te-termination-point-config

 grouping te-topologies-augment {

   container te {
     presence "TE support.";

     container templates {
       list node-template {
         if-feature template;
         key "name";
         leaf name {
           type te-template-name;
         }
         uses template-attributes;
         uses te-node-config-attributes-template;
       } // node-template

       list link-template {
         if-feature template;
         key "name";
         leaf name {
           type te-template-name;
         }
         uses template-attributes;
         uses te-link-config-attributes;
       } // link-template
     } // templates
   } // te
 } // te-topologies-augment

 grouping te-topology-augment {

   container te {
     presence "TE support.";
     leaf provider-id {
       type te-global-id;
     }
     leaf client-id {
       type te-global-id;
     }
     leaf te-topology-id {
       type te-topology-id;
       mandatory true;
     }

     container config {
       uses te-topology-config;
     } // config
     container state {
       config false;
       uses te-topology-config;
     } // state
   } // te
 } // te-topology-augment

 grouping te-topology-config {
   uses sch:schedules;
   leaf preference {
     type uint8 {
       range "1..255";
     }
   }
 } // te-topology-config

 grouping te-topology-ref {
   leaf provider-id-ref {
     type leafref {
       path "/nw:networks/nw:network[nw:network-id = "
         + "current()/../network-id-ref]/tet:te/tet:provider-id";
       require-instance false;
     }
   }
   leaf client-id-ref {
     type leafref {
       path "/nw:networks/nw:network[nw:network-id = "
         + "current()/../network-id-ref]/tet:te/tet:client-id";
       require-instance false;
     }
   }
   leaf te-topology-id-ref {
     type leafref {
       path "/nw:networks/nw:network[nw:network-id = "
         + "current()/../network-id-ref]/tet:te/tet:te-topology-id";
       require-instance false;
     }
   }
   leaf network-id-ref {
     type leafref {
       path "/nw:networks/nw:network/nw:network-id";
       require-instance false;
     }
   }
 } // te-topology-ref

 grouping te-topology-type {
   container te-topology {
     presence "Indicates TE topology.";
   }
 } // te-topology-type

 grouping template-attributes {
   leaf priority {
     type uint16;
   }
   leaf reference-change-policy {
     type enumeration {
       enum no-action;
       enum not-allowed;
       enum cascade;
     }
   }
 } // template-attributes

 /*
  * Configuration data nodes
  */
 augment "/nw:networks/nw:network/nw:network-types" {
   uses te-topology-type;
 }

 augment "/nw:networks" {
   uses te-topologies-augment;
 }

 augment "/nw:networks/nw:network" {
   uses te-topology-augment;
 }

 augment "/nw:networks/nw:network/nw:node" {
   uses te-node-augment;
 }

 augment "/nw:networks/nw:network/nt:link" {
   uses te-link-augment;
 }

 augment "/nw:networks/nw:network/nw:node/"
       + "nt:t-point" {
   uses te-termination-point-augment;
 }

 container te-node-event {
   leaf event-type {
     type te-topology-event-type;
     description "Event type.";
   }
   uses nw:node-ref;
   uses te-topology-type;
   uses tet:te-node-config-attributes-notification;
   uses tet:te-node-state-derived-notification;
 }
}