module org-openroadm-common-service-types {
  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 2019-03-29;
  }
  import org-openroadm-topology {
    prefix org-openroadm-topology;
    revision-date 2019-05-31;
  }
  import org-openroadm-common-equipment-types {
    prefix org-openroadm-common-equipment-types;
    revision-date 2018-11-30;
  }
  import org-openroadm-common-state-types {
    prefix org-openroadm-common-state-types;
    revision-date 2018-11-30;
  }
  import org-openroadm-common-node-types {
    prefix org-openroadm-common-node-types;
    revision-date 2018-11-30;
  }
  import org-openroadm-resource-types {
    prefix org-openroadm-resource-types;
    revision-date 2018-11-30;
  }
  import org-openroadm-otn-common-types {
    prefix org-openroadm-otn-common-types;
    revision-date 2018-11-30;
  }
  import org-openroadm-common-types {
    prefix org-openroadm-common-types;
    revision-date 2019-05-31;
  }
  import org-openroadm-equipment-states-types {
    prefix org-openroadm-equipment-states-types;
    revision-date 2018-11-30;
  }
  import org-openroadm-service-format {
    prefix org-openroadm-service-format;
    revision-date 2019-05-31;
  }

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

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

  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 rx-direction {
        uses service-port;
      }
    }
  }

  grouping service-identifiers-container {
    container service-identifiers {
      leaf service-name {
        type string;
      }
      leaf common-id {
        type string;
      }
      leaf version-number {
        type uint64;
      }
    }
  }

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

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

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

  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.";
    }
    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 rx-direction {
      uses service-port;
      uses service-lgx;
      uses service-tail;
    }
    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.";
      }
    }
    leaf user-label {
      type string;
      mandatory false;
      description
        "Label for service endpoint, defined by the user";
    }
    container subrate-eth-sla {
      when "(../service-format='Ethernet')" {
        description
          "For any Ethernet services";
      }
      uses org-openroadm-common-service-types:subrate-eth-sla;
    }
  }

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

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

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

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

  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;
      mandatory false;
      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 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 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";
        }
      }
    }
  }

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

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

  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 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.";
    }
    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-z-end {
      uses service-endpoint;
    }
    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;
    }
    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 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;
      }
    }
    container network-topology {
      uses org-openroadm-topology: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;
      }
    }
    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-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 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 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.";
    }
  }
}