netconfcentral logo

org-openroadm-common-service-types@2020-05-29



  module org-openroadm-common-service-types {

    yang-version 1;

    namespace
      "http://org/openroadm/common/service/types";

    prefix
      org-openroadm-common-service-types;

    import ietf-yang-types {
      prefix yang;
      revision-date "2013-07-15";
    }
    import ietf-inet-types {
      prefix inet;
      revision-date "2013-07-15";
    }
    import org-openroadm-routing-constraints {
      prefix
        org-openroadm-routing-constraints;
      revision-date "2020-05-29";
    }
    import org-openroadm-topology {
      prefix org-openroadm-topology;
      revision-date "2020-05-29";
    }
    import org-openroadm-common-equipment-types {
      prefix
        org-openroadm-common-equipment-types;
      revision-date "2019-11-29";
    }
    import org-openroadm-common-state-types {
      prefix
        org-openroadm-common-state-types;
      revision-date "2019-11-29";
    }
    import org-openroadm-common-node-types {
      prefix
        org-openroadm-common-node-types;
      revision-date "2019-11-29";
    }
    import org-openroadm-resource-types {
      prefix org-openroadm-resource-types;
      revision-date "2019-11-29";
    }
    import org-openroadm-otn-common-types {
      prefix
        org-openroadm-otn-common-types;
      revision-date "2020-03-27";
    }
    import org-openroadm-common-types {
      prefix org-openroadm-common-types;
      revision-date "2020-05-29";
    }
    import org-openroadm-equipment-states-types {
      prefix
        org-openroadm-equipment-states-types;
      revision-date "2019-11-29";
    }
    import org-openroadm-service-format {
      prefix org-openroadm-service-format;
      revision-date "2019-11-29";
    }
    import org-openroadm-common-attributes {
      prefix
        org-openroadm-common-attributes;
      revision-date "2020-03-27";
    }

    organization "Open ROADM MSA";

    contact "OpenROADM.org";

    description
      "YANG definitions of common service types.

 Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
 All other rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation and/or
   other materials provided with the distribution.
 * Neither the Members of the Open ROADM MSA Agreement nor the names of its
   contributors may be used to endorse or promote products derived from this software
   without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA  AGREEMENT ''AS IS''
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA  AGREEMENT BE LIABLE FOR ANY DIRECT,
 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE, DATA,
 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE";

    revision "2020-05-29" {
      description "Version 7.1.0";
    }

    revision "2020-03-27" {
      description "Version 7.0.0";
    }

    revision "2019-11-29" {
      description "Version 6.1.0";
    }

    revision "2019-09-27" {
      description "Version 6.0.0";
    }

    revision "2019-05-31" {
      description "Version 5.1.0";
    }

    revision "2019-03-29" {
      description "Version 5.0.0";
    }

    revision "2018-11-30" {
      description "Version 4.1.0";
    }

    revision "2018-09-28" {
      description "Version 4.0.0";
    }

    revision "2018-05-30" {
      description "Version 3.1.0";
    }

    revision "2018-03-30" {
      description "Version 3.0.0";
    }

    revision "2017-12-15" {
      description "Version 2.2";
    }

    revision "2017-09-29" {
      description "Version 2.1";
    }

    revision "2017-07-28" {
      description
        "Version 2.0.1 - added revision-date to imports";
    }

    revision "2017-06-26" {
      description "Version 2.0";
    }

    revision "2016-10-14" {
      description "Version 1.2";
    }


    identity service-resiliency-type-identity {
      base 
      description
        "A unique resiliency type identification of the service.";
    }

    identity unprotected {
      base service-resiliency-type-identity;
      description
        "the service is not protected in the OpenROADM layer";
    }

    identity unprotected-diversely-routed {
      base service-resiliency-type-identity;
      description
        "the service is not protected in the OpenROADM layer, but may be protected in a higher layer
   a coupled service that may be routed partially or fully disjointly is defined";
    }

    identity protected {
      base service-resiliency-type-identity;
      description
        "the service is protected in the OpenROADM layer : the protection is handled
autonomously in this layer";
    }

    identity restorable {
      base service-resiliency-type-identity;
      description
        "the service can be restored autonomously in the OpenROADM layer";
    }

    identity external-trigger-restorable {
      base service-resiliency-type-identity;
      description
        "the service can be restored in the OpenROADM layer, but the restoration is triggered
at a higher layer through service models' rpc";
    }

    typedef rpc-actions {
      type enumeration {
        enum "service-create" {
          value 1;
        }
        enum "service-feasibility-check" {
          value 2;
        }
        enum "service-delete" {
          value 3;
        }
        enum "equipment-notification" {
          value 4;
        }
        enum "temp-service-create" {
          value 5;
        }
        enum "temp-service-delete" {
          value 6;
        }
        enum "service-roll" {
          value 7;
        }
        enum "service-reconfigure" {
          value 8;
        }
        enum "service-restoration" {
          value 9;
        }
        enum "service-reversion" {
          value 10;
        }
        enum "service-reroute" {
          value 11;
        }
        enum "service-reroute-confirm" {
          value 12;
        }
        enum "network-re-optimization" {
          value 13;
        }
        enum
          "service-feasibility-check-bulk" {
          value 14;
        }
        enum "ber-test" {
          value 15;
        }
        enum "controller-parameters-setting" {
          value 16;
        }
      }
      description
        "rpc-actions include all the rpc methods";
    }

    typedef ethernet-encoding-type {
      type enumeration {
        enum "10GBASE-W" {
          value 1;
        }
        enum "10GBASE-R" {
          value 2;
        }
      }
    }

    typedef mapping-mode-type {
      type enumeration {
        enum "GFP-F" {
          value 1;
          reference
            "GFP-F - ITU-T G.7041 SubClause 7.1, Payload Only";

        }
        enum "GFP-E" {
          value 2;
          reference
            "GFP-E - ITU-T G.7041 SubClause 7.9, Payload + Preamble + Ordered Sets";

        }
        enum "PCS-Transparent" {
          value 3;
          reference
            "PCS-Transparent - ITU-T G.709 Subclause 17.2 , CBR10G3 mapping to ODU2e";

        }
      }
    }

    typedef service-layer-type {
      type enumeration {
        enum "wdm" {
          value 1;
        }
        enum "otn" {
          value 2;
        }
      }
    }

    typedef service-notification-types {
      type enumeration {
        enum "service-create-result" {
          value 1;
        }
        enum "service-reconfigure-result" {
          value 2;
        }
        enum "service-delete-result" {
          value 3;
        }
        enum "service-roll-result" {
          value 4;
        }
        enum "service-revert-result" {
          value 5;
        }
        enum "service-reroute-result" {
          value 6;
        }
        enum "service-restoration-result" {
          value 7;
        }
      }
    }

    typedef connection-type {
      type enumeration {
        enum "service" {
          value 1;
        }
        enum "infrastructure" {
          value 2;
        }
        enum "roadm-line" {
          value 3;
        }
      }
    }

    typedef resource-status-type {
      type enumeration {
        enum "deployed" {
          value 1;
          description
            "find the best route using deployed network resources,
regardless of network failures; lifecycle-state must
be deployed and operational-state is ignored.";
        }
        enum "in-service" {
          value 2;
          description
            "find the best route using deployed network resources,
but route around failed resources; lifecycle-state
must be deployed and operational-state must be
inService.";
        }
        enum "planned" {
          value 3;
          description
            "find the best route using both deployed and planned
network resources; lifecycle-state must be planned
or deployed (deploying, deployed-updating, deployed-
augmented, and deploy-failed may be considered
planned states) and operational-state is ignored. if
planned is selected, due-date must be specified in
the service request.";
        }
      }
      default "deployed";
      description
        "identifies the state of network resources required to
complete a service request.  default is deployed";
    }

    typedef service-condition {
      type enumeration {
        enum "restored-temporarily" {
          value 1;
        }
        enum "re-routed-temporarily" {
          value 2;
        }
        enum "activated-for-service" {
          value 3;
        }
        enum "activated-for-further-check" {
          value 4;
        }
        enum
          "activated-for-troubleshooting-failure" {
          value 5;
        }
      }
    }

    grouping service-and-supporting-services {
      description
        "Service identifiers and supporting services details";
      uses service-identifiers-container;

      uses supporting-services-identifiers-and-ends;
    }  // grouping service-and-supporting-services

    grouping supporting-services-identifiers-and-ends {
      container supporting-services {
        list supporting-service-details {
          key "index";
          leaf index {
            type uint16;
            description
              "Service number of the supporting service";
          }

          uses service-identifiers-container;

          uses service-ends-container;
        }  // list supporting-service-details
      }  // container supporting-services
    }  // grouping supporting-services-identifiers-and-ends

    grouping trail-trace {
      description "Trail trace grouping";
      uses org-openroadm-common-attributes:trail-trace-tx;

      uses org-openroadm-common-attributes:trail-trace-other;
    }  // grouping trail-trace

    grouping tcm-attributes {
      description
        "Tandem Connection Monitoring (TCM) attributes";
      leaf layer {
        type uint8 {
          range "1..6";
        }
        description "TCM layer";
      }

      leaf monitoring-mode {
        type enumeration {
          enum "not-terminated" {
            value 0;
            description
              "Not Terminated: no detection or generation.
Overhead is passed through the interface transparently in receive direction
unless extension is set for erase";
          }
          enum "terminated" {
            value 1;
            description
              "Terminated: detection and generation enabled.
Overhead is erased (replaced with all zeros) in receive direction, unless
extension is set to passthrough";
          }
          enum "monitored" {
            value 2;
            description
              "Monitored: detection enabled.
Overhead is passed through the interface transparently in receive direction
unless extension is set for erase";
          }
        }
        description
          "Monitoring mode of the TCM layer";
      }

      leaf ltc-act-enabled {
        type boolean;
        description
          "enable/disable alarm transfer on detection of Loss of Tandem Connection (LTC)";
      }

      leaf proactive-delay-measurement-enabled {
        type boolean;
        description
          "enable/disable proactive Delay Measurement for TCM";
      }

      leaf tcm-direction {
        type org-openroadm-otn-common-types:tcm-direction-enum;
        description "Direction of TCM.";
      }

      uses trail-trace;

      uses org-openroadm-common-attributes:deg-threshold;
    }  // grouping tcm-attributes

    grouping otn-attributes-grp {
      container otn-attributes {
        when
          "(../service-format='OTU' or ../service-format='ODU')" {
          description
            "For any OTN services (OTU and OTN)";
        }
        uses org-openroadm-common-attributes:parent-odu-allocation;

        uses org-openroadm-common-types:fec-grouping {
          description
            "OTN FEC / Forward Error Correction";
        }

        uses org-openroadm-common-attributes:trail-trace-tx;

        uses org-openroadm-common-attributes:trail-trace-other;

        uses org-openroadm-common-attributes:deg-threshold;

        leaf-list reserved-tcm-layer {
          type uint8;
        }

        list tcm {
          key "layer tcm-direction";
          max-elements 12;
          description
            "Tandem Connection Management";
          uses tcm-attributes;
        }  // list tcm
      }  // container otn-attributes
    }  // grouping otn-attributes-grp

    grouping ethernet-subrate-attributes-grp {
      container ethernet-attributes {
        when
          "(../service-format='Ethernet')" {
          description
            "For any Ethernet services";
        }
        uses org-openroadm-common-types:fec-grouping {
          description
            "ETH FEC / Forward Error Correction";
        }

        uses org-openroadm-common-service-types:subrate-eth-sla;
      }  // container ethernet-attributes
    }  // grouping ethernet-subrate-attributes-grp

    grouping service-ends-container {
      container service-a-end {
        uses service-endpoint-summary;
      }  // container service-a-end

      container service-z-end {
        uses service-endpoint-summary;
      }  // container service-z-end
    }  // grouping service-ends-container

    grouping service-endpoint-summary {
      description
        "Brief form of service-endpoint";
      container service-endpoint-details {
        leaf clli {
          type string;
          mandatory true;
          description
            "CLLI. Note this CLLI must match the site associated with the device-id of this endpoint";
        }

        uses org-openroadm-resource-types:device-id;

        container tx-direction {
          uses service-port;
        }  // container tx-direction

        container rx-direction {
          uses service-port;
        }  // container rx-direction
      }  // container service-endpoint-details
    }  // grouping service-endpoint-summary

    grouping service-identifiers-container {
      container service-identifiers {
        leaf service-name {
          type string;
        }

        leaf common-id {
          type string;
        }

        leaf version-number {
          type uint64;
        }
      }  // container service-identifiers
    }  // grouping service-identifiers-container

    grouping configuration-response-common {
      container configuration-response-common {
        leaf request-id {
          type string;
          mandatory true;
        }

        leaf response-code {
          type string;
          mandatory true;
        }

        leaf response-message {
          type string;
        }

        leaf ack-final-indicator {
          type string;
          mandatory true;
        }
      }  // container configuration-response-common
    }  // grouping configuration-response-common

    grouping response-parameters {
      container response-parameters {
        description
          "Violated soft constraints";
        uses org-openroadm-routing-constraints:routing-constraints;
      }  // container response-parameters
    }  // grouping response-parameters

    grouping subrate-eth-sla {
      container subrate-eth-sla {
        presence
          "Explicit assignment of subrate ethernet allocation";
        description
          "SLA (Service Level Agreement) for subrate Ethernet";
        uses org-openroadm-common-types:eth-rate-and-burst-size;
      }  // container subrate-eth-sla
    }  // grouping subrate-eth-sla

    grouping service-endpoint-project {
      description
        "Project Identifier information for service endpoints";
      leaf project-id {
        type string;
        description
          "Project identifier for the service end point";
      }

      leaf project-note {
        type string;
        description
          "Additional details associated with the service end point project";
      }
    }  // grouping service-endpoint-project

    grouping service-endpoint {
      leaf service-format {
        type org-openroadm-service-format:service-format;
        mandatory true;
        description
          "Format of the requested service: Ethernet, OTU, etc.";
      }

      leaf service-rate {
        when
          "../service-format != 'OMS' and ../service-format != 'ODU'" {
          description
            "service rate not applicable when service
format is roadmline or ODU; valid for OTU since service-rate has
already been supported for wdm layer OTU services (100 for OTU4)";
        }
        type uint32;
        description
          "Rate of the requested service in GBps";
      }

      leaf other-service-format-and-rate {
        type string;
        description
          "Used when service-format is set to other in the bookend xponder use case.
The use of other-service-format-and-rate is not standardized in the Open ROADM MSA
and intended to allow the controller to support non-Open ROADM service formats.
This value encodes both the service format and the rate supported.
This field should not be specified when service format != other.";
      }

      leaf otu-service-rate {
        when "../service-format = 'OTU'" {
          description
            "only applicable for OTU services";
        }
        type identityref {
          base org-openroadm-otn-common-types:otu-rate-identity;
        }
        description
          "OTU Rate of the requested service";
      }

      leaf odu-service-rate {
        when "../service-format = 'ODU'" {
          description
            "only applicable for ODU services";
        }
        type identityref {
          base org-openroadm-otn-common-types:odu-rate-identity;
        }
        description
          "ODU Rate of the requested service";
      }

      leaf ethernet-encoding {
        when
          "(../service-format='Ethernet')
and
(../service-rate=10)" {
          description
            "Applicable only to Ethernet 10G services";
        }
        type ethernet-encoding-type;
        description "Ethernet encoding type";
      }

      leaf mapping-mode {
        when
          "(../service-format='Ethernet')
and
(../service-rate=10)" {
          description
            "Mapping Mode, currently only defined for Ethernet 10G services";
        }
        type mapping-mode-type;
        description "Mapping mode.";
      }

      uses otn-attributes-grp;

      leaf clli {
        type string;
        mandatory true;
        description
          "CLLI. Note this CLLI must match the site associated with the device-id of this
endpoint";
      }

      uses org-openroadm-resource-types:device-id;

      container tx-direction {
        uses service-port;

        uses service-lgx;

        uses service-tail;
      }  // container tx-direction

      container rx-direction {
        uses service-port;

        uses service-lgx;

        uses service-tail;
      }  // container rx-direction

      leaf optic-type {
        type org-openroadm-common-equipment-types:optic-types;
      }

      container router {
        description
          "Needed for communication with DWDM pluggable";
        leaf node-id {
          type org-openroadm-common-node-types:node-id-type;
          description
            "Node id. This is reported against the service, but may not get reflected in the service in the network.";
        }

        leaf ip-address {
          type inet:ip-address;
          description
            "Router IP Address. This is reported against the service, but may not get reflected in the service in the network.";
        }

        leaf url {
          type string;
          description
            "URL needed for communication with DWDM pluggable. This is reported against the service, but may not get reflected in the service in the network.";
        }
      }  // container router

      leaf user-label {
        type string;
        description
          "Label for service endpoint, defined by the user";
      }

      uses ethernet-subrate-attributes-grp;
    }  // grouping service-endpoint

    grouping sdnc-request-header {
      container sdnc-request-header {
        leaf request-id {
          type string;
        }

        leaf rpc-action {
          type rpc-actions;
        }

        leaf notification-url {
          type string;
        }

        leaf request-system-id {
          type string;
        }
      }  // container sdnc-request-header
    }  // grouping sdnc-request-header

    grouping service-port {
      container port {
        description
          "From the device model perspective the port-device-name plus the port-circuit-pack-name plus the port-name uniquely identifies the port.
From the network model perspective the openroadm-topology-ref plus port-device-name plus port-name uniquely identify the termination point in the network model.";
        leaf port-device-name {
          type string;
        }

        leaf port-circuit-pack-name {
          type string;
        }

        leaf port-type {
          type string;
        }

        leaf port-name {
          type string;
        }

        leaf port-rack {
          type string;
        }

        leaf port-shelf {
          type string;
        }

        leaf port-slot {
          type string;
        }

        leaf port-sub-slot {
          type string;
        }
      }  // container port
    }  // grouping service-port

    grouping service-lgx {
      container lgx {
        leaf lgx-device-name {
          type string;
        }

        leaf lgx-port-name {
          type string;
        }

        leaf lgx-port-rack {
          type string;
        }

        leaf lgx-port-shelf {
          type string;
        }
      }  // container lgx
    }  // grouping service-lgx

    grouping service-tail {
      container tail {
        container tail-roadm {
          description
            "ROADM on which the transponder is connected to (TID, IP Address,
or FQDN)";
          uses org-openroadm-resource-types:device-id;
        }  // container tail-roadm

        container xponder-port {
          description
            "Muxponder port used in tail, that will get used as a service endpoint.";
          leaf circuit-pack-name {
            type string;
          }

          leaf port-name {
            type string;
          }
        }  // container xponder-port

        leaf tail-roadm-port-aid {
          type string;
          description
            "This will provide the transponder port needed to inter-city ROADM
connection";
        }

        leaf tail-roadm-port-rack-location {
          type string;
          description
            "Transponder's location";
        }
      }  // container tail
    }  // grouping service-tail

    grouping service-information {
      leaf due-date {
        type yang:date-and-time;
        description
          "Date and time service to be turn up. If time is not specified for a given date, default to midnight. Service turned up immediately if no due date is specified";
      }

      leaf end-date {
        type yang:date-and-time;
        description
          "Date and time service to be removed";
      }

      uses eventHorizon;

      leaf nc-code {
        type string;
        description
          "NC code applied to wavelength service only. This is reported against the service, but may not get reflected in the service in the network.";
      }

      leaf nci-code {
        type string;
        description
          "NCI code applied to wavelength service only. This is reported against the service, but may not get reflected in the service in the network.";
      }

      leaf secondary-nci-code {
        type string;
        description
          "NC code applied to wavelength service only. This is reported against the service, but may not get reflected in the service in the network.";
      }

      leaf customer {
        type string;
        description
          "To be included in ticket information. This is reported against the service, but may not get reflected in the service in the network.";
      }

      leaf customer-contact {
        type string;
        description
          "Customer contact information to be included in ticket information. This is reported against the service, but may not get reflected in the service in the network.";
      }

      leaf operator-contact {
        type string;
        description
          "Operator contact information to be included in ticket information. This is reported against the service, but may not get reflected in the service in the network.";
      }

      leaf service-layer {
        type service-layer-type;
        default "wdm";
        description
          "Layer associated with service (e.g. wdm or otn)";
      }

      leaf clli-network-ref {
        type string;
        description
          "Assumption: a service would not span multiple clli-network layers.
Reference to the network-id of the clli-network layer.";
      }

      leaf openroadm-network-ref {
        type string;
        description
          "Assumption: a service would not span multiple openroadm-network layers.
Reference to the network-id of the openroadm-network layer.";
      }

      leaf openroadm-topology-ref {
        type string;
        description
          "Assumption: a service would not span multiple topology layers.
Reference to the network-id of either the openroadm-topology
or the otn-topology layer depending upon service-layer (wdm or otn).";
      }

      leaf sla-id {
        type string;
        description
          "Service Level Agreement";
      }

      leaf bandwidth-calendaring {
        type boolean;
        description
          "True if service is active only during a specific time period";
      }

      container bw-calendaring-parameters {
        when
          "../bandwidth-calendaring = 'true'" {
          description
            "Includes all attributes associated with bandwidth calendaring option.
Used to set service profile : each service corresponds to one specific
time-period. Services defined on complementary time periods can be linked
together through the coupled-service attribute ";
        }
        list bw-calendaring-coupled-services {
          key "service-index";
          leaf service-index {
            type uint16;
            description
              "service-number of the service that may be associated to the considered service";
          }

          leaf service-name {
            type string;
            description
              "service-name of the service that may be associated to the considered service in service-list";
          }

          leaf common-id {
            type string;
            description
              "common-id of the service that may be associated to the considered service in temp-service-list";
          }

          leaf version-number {
            type uint64;
            description
              "common-id of the service that may be associated to the considered service in versioned-service-list";
          }
        }  // list bw-calendaring-coupled-services

        list recurrence-pattern {
          key "recurrence-id";
          leaf recurrence-id {
            type uint32;
            description
              "id of the pattern defining the time during which the service is active ";
          }

          leaf-list day-of-the-week {
            type enumeration {
              enum "Monday" {
                value 1;
              }
              enum "Tuesday" {
                value 2;
              }
              enum "Wednesday" {
                value 3;
              }
              enum "Thursday" {
                value 4;
              }
              enum "Friday" {
                value 5;
              }
              enum "Saturday" {
                value 6;
              }
              enum "Sunday" {
                value 7;
              }
            }
            description
              "Each day for which the service is active from stat-time to end-time";
          }

          leaf start-time {
            type string {
              pattern '\d{2}:\d{2}:\d{2}';
            }
            description
              "start time expressed as hour:min:seconds";
          }

          leaf end-time {
            type string {
              pattern '\d{2}:\d{2}:\d{2}';
            }
            description
              "end time expressed as hour:min:seconds";
          }
        }  // list recurrence-pattern
      }  // container bw-calendaring-parameters
    }  // grouping service-information

    grouping routing-metric {
      container routing-metric {
        description
          "Describes the metrics used to route a service.
All parameters of integer type, to set the priority of the routing criterion
'0' means the criterion is not used,
'1'coresponds to the highest priority,
'255'coresponds to the lowest priority.
Priority might be handled in several way : 1) To select one from several paths with the same metrics,
using lower priority metrics until metrics calculated allow the selection; 2) Using priority as
a weight for composite metric calculation";
        leaf wdm-hop-count {
          type uint8 {
            range "0..255";
          }
          default "1";
          description
            "Metric corresponding to the number of hop in the wdm layer";
        }

        leaf otn-hop-count {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Metric corresponding to the number of hop in the otn layer";
        }

        leaf wdm-load {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Metric corresponding to the load of the wdm layer
Can be used to avoid using heavy loaded links ";
        }

        leaf otn-load {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Metric corresponding to the load of the otn layer.
Can be used to avoid using heavy loaded links/switchs ";
        }

        leaf latency {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Metric corresponding to the latency. Total path latency can be calculated from
SRLG length of the OMS and the latency introduced by the equipment";
        }

        leaf distance {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Metric associated with the distance. Total path distance can be
calculated from SRLG length of the OMS";
        }

        leaf wdm-TE-metric {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Used when routing shall be performed according to specific pre-defined
TE-Metric. Total path metric can be calculated from OMS TE-metric attribute
defined in org-openroadm-link module";
        }

        leaf adaptation-number {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Metric associated with the adaptation between layers. Total path metric can
can be calculated from the total number of transition between layers";
        }

        leaf otn-TE-metric {
          type uint8 {
            range "0..255";
          }
          default "0";
          description
            "Used when routing shall be performed according to specific pre-defined
metric associated with OTN (OTU/ODU level)";
        }
      }  // container routing-metric
    }  // grouping routing-metric

    grouping service-resiliency {
      container service-resiliency {
        leaf resiliency {
          type identityref {
            base service-resiliency-type-identity;
          }
          description
            "describes the type of resiliency and the associated layer ";
        }

        leaf revertive {
          when
            "../resiliency != 'unprotected' and ../resiliency != 'unprotected-diversely-routed'" {
            description
              "revertive not applicable when service is neither protected nor restorable";
          }
          type boolean;
          description
            "defines if the service shall revert to the initial working path
after protection or restoration has been triggered and fault condition
has disappeared";
        }

        leaf wait-to-restore {
          when "../revertive = 'true'" {
            description
              "wait-to-restore applies for service defined as revertive ";
          }
          type uint64;
          units "ms";
          description
            "time delay to revert to initial path after conditions for reversion are satisfied";
        }

        leaf holdoff-time {
          when
            "../resiliency != 'unprotected' and ../resiliency != 'unprotected-diversely-routed'" {
            description
              "holdoff-time applies when services are either protected or restorable";
          }
          type uint64;
          units "ms";
          description
            "time delay to initiate a protection or restoration event";
        }

        leaf pre-calculated-backup-path-number {
          when
            "../resiliency = 'restorable' or ../resiliency = 'external-trigger-restorable'" {
            description
              "when service is restorable, defines the
number of paths that shall be or have been pre-calculated";
          }
          type uint8;
          description
            "Associated to service-create / reconfigure / feasibility-check rpcs
--> defines the target number of backup-paths to be calculated by PCE. This is an
optional parameter : operator can provide it to conform with specific engineering rules.
If not provided, PCE will evaluate the number of backup path to be provided automously.
Associated with service --> gives the effective number of backup-paths
returned/calculated by PCE that can be find in topology container";
        }

        container coupled-service {
          when
            "../resiliency = 'unprotected-diversely-routed'" {
            description
              "for unprotected-diversely-routed services only one path is defined.
Allows providing a link between services that are coupled
through a routing disjonction criterion";
          }
          list coupled-services {
            key "service-index";
            leaf service-index {
              type uint16;
              description
                "service-number of the service that may be routed disjointly to the considered service";
            }

            leaf service-name {
              type string;
              description
                "service-name of the service that may be routed disjointly to the considered service in service-list";
            }

            leaf common-id {
              type string;
              description
                "common-id of the service that may be routed disjointly to the considered service in temp-service-list";
            }

            leaf version-number {
              type uint64;
              description
                "common-id of the service that may be routed disjointly to the considered service in versioned-service-list";
            }
          }  // list coupled-services
        }  // container coupled-service
      }  // container service-resiliency
    }  // grouping service-resiliency

    grouping service-order {
      description
        "Service Order information for service";
      leaf order-id {
        type string;
        description
          "Order identifier for this service";
      }

      leaf order-note {
        type string;
        description
          "Additional details associated with the service order";
      }
    }  // grouping service-order

    grouping resource-status {
      description
        "Grouping used to consisistenty apply resource-status
naming to appropriate RPC.";
      leaf resource-status {
        type resource-status-type;
        description
          "identifies the state of network resources required
to complete a service request.";
      }
    }  // grouping resource-status

    grouping service {
      leaf service-name {
        type string;
        description
          "Identifier for the service to be created in
the ROADM network, e.g., CLFI, CLCI, etc.";
      }

      leaf common-id {
        type string;
        description
          "To be used by the ROADM controller to identify the routing
constraints received from planning application (PED).";
      }

      uses service-order;

      uses sdnc-request-header;

      uses service-resiliency;

      uses routing-metric;

      leaf connection-type {
        type connection-type;
        mandatory true;
        description "Connection type";
      }

      leaf lifecycle-state {
        type org-openroadm-common-state-types:lifecycle-state;
        description
          "Lifecycle State of service. Whether it is planned, deployed, in maintenance, etc.";
      }

      uses resource-status;

      leaf administrative-state {
        type org-openroadm-equipment-states-types:admin-states;
        description
          "Administrative State: Intended state of service";
      }

      leaf operational-state {
        type org-openroadm-common-state-types:state;
        config false;
        description
          "Operational State: Actual state of service";
      }

      leaf condition {
        type service-condition;
        description
          "Service Condition: Additional information about the state of the service. Only sent when applicable.";
      }

      container service-a-end {
        uses service-endpoint;

        uses service-endpoint-project;
      }  // container service-a-end

      container service-z-end {
        uses service-endpoint;

        uses service-endpoint-project;
      }  // container service-z-end

      uses org-openroadm-routing-constraints:routing-constraints;

      uses service-information;

      leaf latency {
        type uint32;
        description "Latency on service";
      }

      leaf-list fiber-span-srlgs {
        type string;
        description
          "Shared risk link group identifiers";
      }

      list equipment-srgs {
        key "srg-number";
        uses org-openroadm-resource-types:srg-number;
      }  // list equipment-srgs

      leaf-list supporting-service-name {
        type string;
        description
          "The service name that this runs over top. If connection-type is service, then this is the related
connection-type = infrastructure service, for example.";
      }

      leaf current-active-path-id {
        type uint8;
        description
          "defines the current active path : '0' if active path is the working path
id of the active backup path if protection or restoration has been triggered";
      }

      container topology {
        description
          "topology corresponds to working-path which is the default path. It defines the initial path
to which services defined as revertive may revert to when the failure condition disappear";
        uses org-openroadm-topology:topology;
      }  // container topology

      container backup-topology {
        list backup-path {
          key "backup-path-id";
          leaf backup-path-id {
            type uint8 {
              range "1..255";
            }
            description
              "Several backup paths may be used when backup-paths are pre-calculated.
Backup-path-id avoids 0 which is associated with working path in current-active-path";
          }

          leaf failure-case-id {
            type string;
            description
              "A failure case Id can be used to associate a backup-path to a specific failure (srlg, OMS,...)";
          }

          uses org-openroadm-topology:topology;
        }  // list backup-path
      }  // container backup-topology

      container network-topology {
        uses org-openroadm-topology:network-topology;
      }  // container network-topology

      container network-backup-topology {
        list backup-path {
          key "backup-path-id";
          leaf backup-path-id {
            type uint8 {
              range "1..255";
            }
            description
              "Several backup paths may be used when backup-paths are pre-calculated.
Backup-path-id avoids 0 which is associated with working path in current-active-path";
          }

          leaf failure-case-id {
            type string;
            description
              "A failure case Id can be used to associate a backup-path to a specific failure (srlg, OMS,...)";
          }

          uses org-openroadm-topology:network-topology;
        }  // list backup-path
      }  // container network-backup-topology

      leaf is-bandwidth-locked {
        type boolean;
        default "false";
        description
          "Bandwidth lock (true, false) indicates whether the service is administratively
prohibited from taking on more capacity - ie whether it can be used as a supporting
service in any new service creations. Unlike administrative status, this does not
impact any previous planned or deployed services.";
      }
    }  // grouping service

    grouping service-notification-result {
      leaf service-name {
        type string;
        description
          "Identifier for the service e.g., CLFI, CLCI, etc.";
      }

      leaf version-number {
        type uint64;
        description
          "Identifier for the versioned service";
      }

      leaf common-id {
        type string;
        description
          "Identifier for the temp service";
      }

      leaf actual-date {
        type yang:date-and-time;
        description
          "Actual date and time (if successful)";
      }
    }  // grouping service-notification-result

    grouping equipment-info {
      leaf equipment-identifier {
        type string;
      }

      leaf equipment-type {
        type string;
        description
          "The set of valid value is derived from the equipment-type grouping used in the device model.";
      }

      leaf equipment-quantity {
        type uint32;
      }

      leaf lifecycle-state {
        type org-openroadm-common-state-types:lifecycle-state;
      }
    }  // grouping equipment-info

    grouping eventHorizon {
      leaf eventHorizonStart {
        type yang:date-and-time;
        description
          "Start time to ensure that the service is routable and viable. Required resources shall
be considered reserved from this time. If not provided, defaults to due-date.";
      }

      leaf eventHorizonEnd {
        type yang:date-and-time;
        description
          "End time to ensure that the service is routable and viable. Required resources shall
be considered reserved until this time. If not provided, defaults to end-date.";
      }
    }  // grouping eventHorizon
  }  // module org-openroadm-common-service-types