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 "2021-12-10";
    }
    import org-openroadm-topology {
      prefix org-openroadm-topology;
      revision-date "2022-03-25";
    }
    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 "2021-05-28";
    }
    import org-openroadm-resource-types {
      prefix org-openroadm-resource-types;
      revision-date "2022-03-25";
    }
    import org-openroadm-otn-common-types {
      prefix
        org-openroadm-otn-common-types;
      revision-date "2021-09-24";
    }
    import org-openroadm-common-types {
      prefix org-openroadm-common-types;
      revision-date "2022-03-25";
    }
    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 "2021-09-24";
    }
    import org-openroadm-common-phy-codes {
      prefix
        org-openroadm-common-phy-codes;
      revision-date "2021-05-28";
    }
    import org-openroadm-common-optical-channel-types {
      prefix
        org-openroadm-common-optical-channel-types;
      revision-date "2021-12-10";
    }
    import org-openroadm-resource {
      prefix org-openroadm-resource;
      revision-date "2022-03-25";
    }

    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 "2022-03-25" {
      description "Version 11.0";
    }

    revision "2021-12-10" {
      description "Version 10.1";
    }

    revision "2021-09-24" {
      description "Version 10.0";
    }

    revision "2021-05-28" {
      description "Version 9.1";
    }

    revision "2021-03-26" {
      description "Version 9.0";
    }

    revision "2020-12-11" {
      description "Version 8.1";
    }

    revision "2020-09-25" {
      description "Version 8.0";
    }

    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 {
      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;
        }
        enum "optical-tunnel-create" {
          value 17;
        }
        enum "optical-tunnel-request-cancel" {
          value 18;
        }
        enum
          "fill-catalog-with-or-operational-modes" {
          value 19;
        }
        enum
          "fill-catalog-with-specific-operational-modes" {
          value 20;
        }
      }
      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;
        }
        enum
          "successful-path-computation-resource-reserved" {
          value 8;
        }
        enum "path-computation-failed" {
          value 9;
        }
      }
    }

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

    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 intermediate-site-container {
      description
        "Intermediate site used in the service feasibility check output.
This is different from the service-endpoint structure";
      list intermediate-site {
        key "clli";
        description
          "List of intermediate sites in the service feasiblity check
output response";
        leaf clli {
          type string;
        }

        list node {
          key "node-id";
          leaf node-id {
            type org-openroadm-common-node-types:node-id-type;
            description
              "List of nodes within a CLLI";
          }

          list equipment-required {
            key "equipment-identifier";
            description
              "List of required equipment, including equipment type, state and
quantity";
            uses equipment-info;
          }  // list equipment-required
        }  // list node
      }  // list intermediate-site
    }  // grouping intermediate-site-container

    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 external-interface-characteristics {
      list supported-operational-modes {
        key "preference";
        description
          "list of supported operational modes associated to a preference
for their selection by the Path Computation Engine (1 is the highest priority)
only one operational mode shall be associated to a preference. 2 leaves present
since this mode could be either specific or an openROADM operational-mode";
        leaf preference {
          type int16;
          description
            "preference/priority associated to the operational mode";
        }

        leaf operational-mode-id {
          type string;
          description
            "the supported operational mode : either openROADM or specific ";
        }
      }  // list supported-operational-modes

      leaf min-frequency {
        type org-openroadm-common-optical-channel-types:frequency-THz;
        description
          "Minimum acceptable Frequency in THz.";
      }

      leaf max-frequency {
        type org-openroadm-common-optical-channel-types:frequency-THz;
        description
          "Minimum acceptable Frequency in THz.";
      }

      leaf min-granularity {
        type org-openroadm-common-optical-channel-types:frequency-GHz;
        description
          "Minimum grid granularity in GHz.";
      }
    }  // grouping external-interface-characteristics

    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 is-split-lambda {
        type boolean;
        default "false";
        description
          "This flag allows to specify whether to use split-lambda. It can be user controlled
(or specified) or controller initiated. This is only applicable for line-service or
network ports";
      }

      leaf split-lambda-service-rate {
        when
          "../is-split-lambda = 'true' and
../service-format != 'OMS' and
../service-format != 'ODU'";
        type uint32;
        description
          "This service rate is only applicable when the split-lambda is enabled.
It will help to identify how many wavelengths to use. Only applicable
to the WDM layer and OTUCn services.";
      }

      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.";
      }

      leaf client-phy-code {
        type identityref {
          base org-openroadm-common-phy-codes:client-phy-code-identity;
        }
        description
          "Client PHY Code for the service end point.";
      }

      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;

      list tx-direction {
        key "index";
        leaf index {
          type uint8;
          description
            "Used to list tx-direction attributes for each split-lambda wavelength/service";
        }

        uses service-port;

        uses service-lgx;

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

      list rx-direction {
        key "index";
        leaf index {
          type uint8;
          description
            "used to list rx-direction attributes for each split-lambda wavelength/service";
        }

        uses service-port;

        uses service-lgx;

        uses service-tail;
      }  // list 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;

      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

    typedef existing-resource-reuse-type {
      type enumeration {
        enum "regenerator" {
          value 1;
          description
            "Indicates reuse regenerator";
        }
        enum "wavelength" {
          value 2;
          description
            "Indicates reuse of wavelength";
        }
        enum "spectrum-portion" {
          value 3;
          description
            "Indicates reuse of frequency slot(s). Reuse the exact
or partial portion of the spectrum of the original service
specturm";
        }
        enum "xponder" {
          value 4;
          description
            "This could be a transponder/muxponder/switchponder";
        }
        enum "all" {
          value 99;
          description
            "Reuse all possible options";
        }
      }
      description
        "Used to indicate the type of resource that the existing service
can reuse wherever possible (best-effort)";
    }

    grouping existing-service-grouping {
      container existing-service-attributes {
        description
          "This consists of all the attributes related to the existing service";
        leaf is-existing {
          type boolean;
          description
            "This is set true if feasibility check is on an existing service with or
without new constraints. Feasibility is done as if current service
and its resources are released";
        }

        leaf existing-service-name {
          when "../is-existing = 'true'";
          type string;
          description
            "Name of the existing service";
        }

        leaf reuse-existing-resources {
          type boolean;
          description
            "If true reuse the existing equipment wherever possible";
        }

        leaf-list reusable-existing-resources {
          when
            "../reuse-existing-resources = 'true'";
          type existing-resource-reuse-type;
          description
            "List of existing resources that can be reused;
This list is enabled only when the reuse-existing-equipment
is set true";
        }
      }  // container existing-service-attributes
    }  // grouping existing-service-grouping

    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-circuit-pack-type {
          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;
      }  // container service-a-end

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

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

      uses service-information;

      leaf latency {
        type decimal64 {
          fraction-digits 3;
        }
        units "milliseconds";
        description
          "One-way latency (in milliseconds) 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 service-port-list {
      list port {
        key "circuit-pack-name port-name";
        description
          "List allows to output more than one piece of equipment per CLLI;
Port-name is unique in the context of circuit-pack";
        leaf circuit-pack-name {
          type string;
        }

        leaf port-name {
          type string;
        }

        leaf lifecycle-state {
          type org-openroadm-common-state-types:lifecycle-state;
        }
      }  // list port
    }  // grouping service-port-list

    grouping equipment-info {
      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-identifier {
        type string;
      }

      leaf lifecycle-state {
        type org-openroadm-common-state-types:lifecycle-state;
      }

      leaf equipment-rack {
        type string;
      }

      leaf equipment-shelf {
        type string;
      }

      leaf equipment-slot {
        type string;
      }

      leaf equipment-sub-slot {
        type string;
      }

      leaf is-reused {
        type boolean;
        description
          "This is set true if the equipment-required is being reused for
service roll";
      }

      uses service-port-list;
    }  // 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

    grouping service-hierarchy {
      leaf service-identifier {
        type string;
        description
          "Based on the level in the service hierarchy, this indentifier can be for the
proposed or existing service";
      }

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

      container service-a-end {
        leaf clli {
          type string;
          description
            "Based on the level in the service hierarchy, A-end CLLI of the
proposed or existing service.";
        }
      }  // container service-a-end

      container service-z-end {
        leaf clli {
          type string;
          description
            "Based on the level in the service hierarchy, Z-end CLLI of the
proposed or existing service.";
        }
      }  // container service-z-end

      list supporting-service {
        key "id";
        uses supporting-service;
      }  // list supporting-service

      container transport-assignment {
        container mc-ttp {
          description
            "Media Channel Trail Termination Point (MC-TTP)";
          uses org-openroadm-resource:mc-ttp-attributes;
        }  // container mc-ttp

        list nmc-ctp {
          key "id";
          description
            "List of Network Media Channel Connection Termination Point (NMC-CTP)";
          leaf id {
            type string;
            description
              "This used to indentify the NMC in the MC. For example split-lambda would
have two NMCs";
          }

          uses org-openroadm-resource:nmc-ctp-attributes;
        }  // list nmc-ctp

        container odu-allocation {
          description
            "parent odu allocation";
          leaf trib-port-number {
            type uint16 {
              range "1 .. 80";
            }
            description
              "Assigned tributary port number in parent OPU";
          }

          choice trib-slots-choice {
            description
              "trib slot selection";
            case opu {
              leaf min-trib-slot {
                type uint16;
                description
                  "Minimum assigned trib slots occupied in parent OPU MSI";
              }

              leaf max-trib-slot {
                type uint16;
                description
                  "Maximum assigned trib slots occupied in parent OPU MSI";
              }
            }  // case opu

            case opucn {
              leaf opucn-min-trib-slot {
                type org-openroadm-otn-common-types:opucn-trib-slot-def;
                description
                  "Minimum OPUCn 5G trib slots in the form of TS #A.B (G.709)";
              }

              leaf opucn-max-trib-slot {
                type org-openroadm-otn-common-types:opucn-trib-slot-def;
                description
                  "Maximum OPUCn 5G trib slots in the form of TS #A.B (G.709)";
              }
            }  // case opucn
          }  // choice trib-slots-choice
        }  // container odu-allocation

        leaf is-reused {
          type boolean;
          description
            "This flag is true if the spectral assignment overlaps--in part or in full--with
that of the active instance of the service. A determination whether the overlap
is full or partial requires a detailed comparison of spectral assignments; it
is not indicated here.";
        }
      }  // container transport-assignment
    }  // grouping service-hierarchy

    grouping supporting-service {
      leaf service-identifier {
        type string;
      }

      leaf id {
        type string;
      }

      container service-a-end {
        uses supporting-service-detail;
      }  // container service-a-end

      container service-z-end {
        uses supporting-service-detail;
      }  // container service-z-end
    }  // grouping supporting-service

    grouping supporting-service-detail {
      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 clli {
        type string;
        description
          "CLLI of the supporting service";
      }

      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.";
      }
    }  // grouping supporting-service-detail

    grouping max-regeneration-options {
      leaf max-regeneration-options {
        type uint8;
        default "1";
        description
          "Max regeneration options, is maximum number of regeneration-option-list elements requested in
service-feasibility output. RNC can return less number of regeneration-options based on it's
calculation but should not return more than max-regeneration-options. The goal of this field
is to avoid RNC from having performance issues.";
      }
    }  // grouping max-regeneration-options

    grouping regeneration-option-list {
      list regeneration-option-list {
        key "regeneration-option-rank";
        leaf regeneration-option-rank {
          type uint8;
          description
            "Regen option rank is derived rank based on optical performance or based on other metrics.";
        }

        list regeneration-clli-list {
          key "sequence-id";
          leaf sequence-id {
            type uint8;
            description
              "Sequence id will define order of regeneration location for output path in A to Z direction.";
          }

          leaf regeneration-clli {
            type string;
            description
              "CLLI for the site where regeneraton is located or bring proposed.";
          }

          leaf lifecycle-state {
            type org-openroadm-common-state-types:lifecycle-state;
            description
              "Lifecycle State for regeneration CLLI indicating whether regen is already deployed or being proposed
for at this site.";
          }
        }  // list regeneration-clli-list
      }  // list regeneration-option-list
    }  // grouping regeneration-option-list
  }  // module org-openroadm-common-service-types