Extension of Yang files for OpenROADM

Extension of YANG files for OpenROADM support in devicemanager

Issue-ID: CCSDK-2644
Signed-off-by: Ravi Pendurty <ravi.pendurty@highstreet-technologies.com>
Change-Id: I8ea2594483ae53428a906763aad562fd643229ff
Signed-off-by: Ravi Pendurty <ravi.pendurty@highstreet-technologies.com>

7 files changed, 3272 insertions, 3 deletions

diff --git a/sdnr/wt/data-provider/model/src/main/java/org/opendaylight/yang/gen/v1/http/org/openroadm/pm/types/rev200327/PmDataTypeBuilder.java b/sdnr/wt/data-provider/model/src/main/java/org/opendaylight/yang/gen/v1/http/org/openroadm/pm/types/rev200327/PmDataTypeBuilder.java
new file mode 100644
index 000000000..f470fb6ba
--- /dev/null
+++ b/sdnr/wt/data-provider/model/src/main/java/org/opendaylight/yang/gen/v1/http/org/openroadm/pm/types/rev200327/PmDataTypeBuilder.java
@@ -0,0 +1,23 @@
+package org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev200327;
+import java.lang.String;
+import java.lang.UnsupportedOperationException;
+
+/**
+ * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation.
+ * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32).
+ *
+ * The reason behind putting it under src/main/java is:
+ * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent
+ * loss of user code.
+ *
+ */
+public class PmDataTypeBuilder {
+    private PmDataTypeBuilder() {
+        //Exists only to defeat instantiation.
+    }
+
+    public static PmDataType getDefaultInstance(String defaultValue) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+}
diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-g826-pm-types.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-g826-pm-types.yang
new file mode 100644
index 000000000..ae9410ce4
--- /dev/null
+++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-g826-pm-types.yang
@@ -0,0 +1,97 @@
+module data-provider-g826-pm-types {
+
+    yang-version 1.1;
+    namespace "urn:opendaylight:params:xml:ns:yang:data-provider-g836-pm-types";
+    prefix pmt;
+
+    import data-provider-v2 {
+        prefix uxp;
+    }
+
+    organization
+      "highstreet technologies GmbH";
+    contact
+      "Web:   <https://highstreet-technologies.com>
+       ONAP:  <https://wiki.onap.org/display/DW/ODLUX+DB+API>";
+
+    description
+      "This module defines the perfromance measurement name identities
+       for SDN controller northbound APIs.
+       
+       Copyright 2020 highstreet technologies GmbH Intellectual Property.
+       All rights reserved.
+       
+       Licensed under the Apache License, Version 2.0 (the 'License');
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+       
+         http://www.apache.org/licenses/LICENSE-2.0
+       
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an 'AS IS' BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.";
+
+    revision 2020-04-13 {
+        description
+          "Initial revision";
+        reference
+          "ITU T-REC-G.826 2002-12";
+    }
+
+    // --- typedef
+    identity performance-measurement-type-id {
+        base uxp:performance-measurement-type-id;
+        description
+          "An abstract base performance measurement type which must not be 
+           used as reference in data objects.";
+    }
+
+    identity errored-block {
+        base performance-measurement-type-id;
+        description
+          "errored block (EB):
+           A block in which one or more bits are in error.";
+    }
+
+    identity errored-second {
+        base performance-measurement-type-id;
+        description
+          "errored second (ES): 
+           A one-second period with one or more errored blocks or at least 
+           one defect.";
+    }
+
+    identity severely-errored-second {
+        base performance-measurement-type-id;
+        description
+          "severely errored second (SES): 
+           A one-second period which contains ≥30% errored blocks or at least 
+           one defect. SES is a subset of ES.";
+    }
+
+    identity errored-second-ratio {
+        base performance-measurement-type-id;
+        description
+          "errored second ratio (ESR): 
+           The ratio of ES to total seconds in available time during a fixed 
+           measurement interval. ";
+    }
+
+    identity severely-errored-second-ratio {
+        base performance-measurement-type-id;
+        description
+          "severely errored second ratio (SESR):
+           The ratio of SES to total seconds in available time during a fixed 
+           measurement interval.";
+    }
+
+    identity background-block-error-ratio {
+        base performance-measurement-type-id;
+        description
+          "background block error ratio (BBER): 
+           The ratio of Background Block Errors (BBE) to total blocks in 
+           available time during a fixed measurement interval.";
+    }
+}
diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-openroadm-pm-types.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-openroadm-pm-types.yang
new file mode 100644
index 000000000..2a3fb17a8
--- /dev/null
+++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-openroadm-pm-types.yang
@@ -0,0 +1,609 @@
+module data-provider-openroadm-pm-types {
+
+    yang-version 1.1;
+    namespace "urn:opendaylight:params:xml:ns:yang:data-provider-openroadm-pm-types";
+    prefix pmt;
+
+    import data-provider-v2 {
+        prefix uxp;
+    }
+
+    organization
+      "highstreet technologies GmbH";
+    contact
+      "Web:   <https://highstreet-technologies.com>
+       ONAP:  <https://wiki.onap.org/display/DW/ODLUX+DB+API>";
+
+    description
+      "This module defines the perfromance measurement name identities
+       for SDN controller northbound APIs.
+       
+       Copyright 2020 highstreet technologies GmbH Intellectual Property.
+       All rights reserved.
+       
+       Licensed under the Apache License, Version 2.0 (the 'License');
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+       
+         http://www.apache.org/licenses/LICENSE-2.0
+       
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an 'AS IS' BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.";
+
+    revision 2020-04-13 {
+        description
+          "Initial revision";
+        reference
+          "https://jira.onap.org/browse/SDNC-???";
+    }
+
+    // --- typedef
+    identity performance-measurement-type-id {
+        base uxp:performance-measurement-type-id;
+        description
+          "An abstract base performance measurement type which must not be used as 
+           reference in data objects.";
+    }
+
+    // [sko] no need to define vendor extension - yang augment should be used
+    //       SDN Conroller will ignor such values.
+    // identity vendorExtension {
+    //     base performance-measurement-type-id;
+    //     description
+    //       "vendor extension";
+    // }
+
+    identity bitErrorRate {
+        base performance-measurement-type-id;
+        description
+          "Bit error rate (BER)";
+    }
+    identity opticalPowerOutput {
+        base performance-measurement-type-id;
+        description
+          "Optical Power Output (OPOUT-OTS, OPOUT-OMS, OPT-OCH). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+    }
+    identity opticalReturnLoss {
+        base performance-measurement-type-id;
+        description
+          "Optical Return Loss (ORL-OTS) - at MW port(s) B";
+    }
+    identity opticalPowerInput {
+        base performance-measurement-type-id;
+        description
+          "Optical Power Input (OPIN-OTS, OPIN-OMS, OPR-OCH). Total optical power";
+    }
+    identity codeViolations {
+        base performance-measurement-type-id;
+        description
+          "Code Violations (CV)";
+    }
+
+    // [sko] exists already in G826
+    // identity erroredSeconds {
+    //     base performance-measurement-type-id;
+    //     description
+    //       "Errored Seconds (ES)";
+    // }
+
+    // [sko] exists already in G826
+    // identity severelyErroredSeconds {
+    //     base performance-measurement-type-id;
+    //     description
+    //       "Severely Errored Seconds (SES)";
+    // }
+
+    identity unavailableSeconds {
+        base performance-measurement-type-id;
+        description
+          "Unavailable Seconds (UAS)";
+    }
+    identity inFrames {
+        base performance-measurement-type-id;
+        description
+          "In frames (INFRAMES-E)";
+    }
+    identity inFramesErrored {
+        base performance-measurement-type-id;
+        description
+          "In frames errored (INFRAMESERR-E)";
+    }
+    identity outFrames {
+        base performance-measurement-type-id;
+        description
+          "Out frames (OUTFRAMES-E)";
+    }
+    identity erroredSecondsEthernet {
+        base performance-measurement-type-id;
+        description
+          "Errored Seconds Ethernet (ES-E)";
+    }
+    identity severelyErroredSecondsEthernet {
+        base performance-measurement-type-id;
+        description
+          "Severely Errored Seconds, Ethernet (SES-E)";
+    }
+    identity unavailableSecondsEthernet {
+        base performance-measurement-type-id;
+        description
+          "Unavailable Seconds, Ethernet (UAS-E)";
+    }
+    identity erroredBlockCount {
+        base performance-measurement-type-id;
+        description
+          "Errored block count";
+    }
+    identity delay {
+        base performance-measurement-type-id;
+        description
+          "Number of frames between a DMValue toggle event and the received DMp signal value toggle event";
+    }
+    identity defectSeconds {
+        base performance-measurement-type-id;
+        description
+          "Defect Seconds (DS)";
+    }
+    identity backwardIncomingAlignmentError {
+        base performance-measurement-type-id;
+        description
+          "Backward Incoming Alignment Error (BIAE)";
+    }
+    identity incomingAlignmentError {
+        base performance-measurement-type-id;
+        description
+          "Incoming Alignment Error (IAE)";
+    }
+    identity opticalPowerOutputMin {
+        base performance-measurement-type-id;
+        description
+          "Minimum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+    }
+    identity opticalPowerOutputMax {
+        base performance-measurement-type-id;
+        description
+          "Maximum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+    }
+    identity opticalPowerOutputAvg {
+        base performance-measurement-type-id;
+        description
+          "Average Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+    }
+    identity opticalPowerInputMin {
+        base performance-measurement-type-id;
+        description
+          "Minimum Optical Power Input (OPIN-OTS). Total optical power";
+    }
+    identity opticalPowerInputMax {
+        base performance-measurement-type-id;
+        description
+          "Maximum Optical Power Input (OPIN-OTS). Total optical power";
+    }
+    identity opticalPowerInputAvg {
+        base performance-measurement-type-id;
+        description
+          "Average Optical Power Input (OPIN-OTS). Total optical power";
+    }
+    identity opticalPowerOutputOSC {
+        base performance-measurement-type-id;
+        description
+          "OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+    }
+    identity opticalPowerOutputOSCMin {
+        base performance-measurement-type-id;
+        description
+          "Minimum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+    }
+    identity opticalPowerOutputOSCMax {
+        base performance-measurement-type-id;
+        description
+          "Maximum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+    }
+    identity opticalPowerOutputOSCAvg {
+        base performance-measurement-type-id;
+        description
+          "Average OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+    }
+    identity opticalPowerInputOSC {
+        base performance-measurement-type-id;
+        description
+          "OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+    }
+    identity opticalPowerInputOSCMin {
+        base performance-measurement-type-id;
+        description
+          "Minimum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+    }
+    identity opticalPowerInputOSCMax {
+        base performance-measurement-type-id;
+        description
+          "Maximum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+    }
+    identity opticalPowerInputOSCAvg {
+        base performance-measurement-type-id;
+        description
+          "Average OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+    }
+    identity preFECCorrectedErrors {
+        base performance-measurement-type-id;
+        description
+          "pFEC corrected Errors";
+    }
+    identity totalOpticalPowerInput {
+        base performance-measurement-type-id;
+        description
+          "Total Optical Power Input.";
+    }
+    identity totalOpticalPowerInputMin {
+        base performance-measurement-type-id;
+        description
+          "Minimum Total Optical Power Input.";
+    }
+    identity totalOpticalPowerInputMax {
+        base performance-measurement-type-id;
+        description
+          "Maximum Total Optical Power Input.";
+    }
+    identity totalOpticalPowerInputAvg {
+        base performance-measurement-type-id;
+        description
+          "Average Total Optical Power Input.";
+    }
+    identity FECCorrectableBlocks {
+        base performance-measurement-type-id;
+        description
+          "FEC Correctable Blocks.";
+    }
+    identity FECUncorrectableBlocks {
+        base performance-measurement-type-id;
+        description
+          "FEC Uncorrectable Blocks.";
+    }
+    identity BIPErrorCounter {
+        base performance-measurement-type-id;
+        description
+          "BIP Error Counter";
+    }
+    identity protectionSwitchingCount {
+        base performance-measurement-type-id;
+        description
+          "Protection Switching Count (PSC)";
+    }
+    identity protectionSwitchingDuration {
+        base performance-measurement-type-id;
+        description
+          "Protection Switching Duration in seconds (PSD)";
+    }
+    identity erroredBlockCountTCM1-up {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM1 up direction.";
+    }
+    identity erroredBlockCountTCM2-up {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM2 up direction.";
+    }
+    identity erroredBlockCountTCM3-up {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM3 up direction.";
+    }
+    identity erroredBlockCountTCM4-up {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM4 up direction.";
+    }
+    identity erroredBlockCountTCM5-up {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM5 up direction.";
+    }
+    identity erroredBlockCountTCM6-up {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM6 up direction.";
+    }
+    identity delayTCM1-up {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM1 up direction.";
+    }
+    identity delayTCM2-up {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM2 up direction.";
+    }
+    identity delayTCM3-up {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM3 up direction.";
+    }
+    identity delayTCM4-up {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM4 up direction.";
+    }
+    identity delayTCM5-up {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM5 up direction.";
+    }
+    identity delayTCM6-up {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM6 up direction.";
+    }
+    identity erroredBlockCountTCM1-down {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM1 down direction.";
+    }
+    identity erroredBlockCountTCM2-down {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM2 down direction.";
+    }
+    identity erroredBlockCountTCM3-down {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM3 down direction.";
+    }
+    identity erroredBlockCountTCM4-down {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM4 down direction.";
+    }
+    identity erroredBlockCountTCM5-down {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM5 down direction.";
+    }
+    identity erroredBlockCountTCM6-down {
+        base performance-measurement-type-id;
+        description
+          "errored Blocks Count on TCM6 down direction.";
+    }
+    identity delayTCM1-down {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM1 down direction.";
+    }
+    identity delayTCM2-down {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM2 down direction.";
+    }
+    identity delayTCM3-down {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM3 down direction.";
+    }
+    identity delayTCM4-down {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM4 down direction.";
+    }
+    identity delayTCM5-down {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM5 down direction.";
+    }
+    identity delayTCM6-down {
+        base performance-measurement-type-id;
+        description
+          "Delay on TCM6 down direction.";
+    }
+    identity partialRateDiscard {
+        base performance-measurement-type-id;
+        description
+          "Discarded packet as a result of policing or rate limiting for subrate ethernet.";
+    }
+    identity erroredSecondsTCM1-up {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM1 up direction.";
+    }
+    identity erroredSecondsTCM2-up {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM2 up direction.";
+    }
+    identity erroredSecondsTCM3-up {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM3 up direction.";
+    }
+    identity erroredSecondsTCM4-up {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM4 up direction.";
+    }
+    identity erroredSecondsTCM5-up {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM5 up direction.";
+    }
+    identity erroredSecondsTCM6-up {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM6 up direction.";
+    }
+    identity severelyErroredSecondsTCM1-up {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM1 up direction.";
+    }
+    identity severelyErroredSecondsTCM2-up {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM2 up direction.";
+    }
+    identity severelyErroredSecondsTCM3-up {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM3 up direction.";
+    }
+    identity severelyErroredSecondsTCM4-up {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM4 up direction.";
+    }
+    identity severelyErroredSecondsTCM5-up {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM5 up direction.";
+    }
+    identity severelyErroredSecondsTCM6-up {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM6 up direction.";
+    }
+    identity unavailableSecondsTCM1-up {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM1 up direction.";
+    }
+    identity unavailableSecondsTCM2-up {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM2 up direction.";
+    }
+    identity unavailableSecondsTCM3-up {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM3 up direction.";
+    }
+    identity unavailableSecondsTCM4-up {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM4 up direction.";
+    }
+    identity unavailableSecondsTCM5-up {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM5 up direction.";
+    }
+    identity unavailableSecondsTCM6-up {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM6 up direction.";
+    }
+    identity erroredSecondsTCM1-down {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM1 down direction.";
+    }
+    identity erroredSecondsTCM2-down {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM2 down direction.";
+    }
+    identity erroredSecondsTCM3-down {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM3 down direction.";
+    }
+    identity erroredSecondsTCM4-down {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM4 down direction.";
+    }
+    identity erroredSecondsTCM5-down {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM5 down direction.";
+    }
+    identity erroredSecondsTCM6-down {
+        base performance-measurement-type-id;
+        description
+          "errored Seconds Count on TCM6 down direction.";
+    }
+    identity severelyErroredSecondsTCM1-down {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM1 down direction.";
+    }
+    identity severelyErroredSecondsTCM2-down {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM2 down direction.";
+    }
+    identity severelyErroredSecondsTCM3-down {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM3 down direction.";
+    }
+    identity severelyErroredSecondsTCM4-down {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM4 down direction.";
+    }
+    identity severelyErroredSecondsTCM5-down {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM5 down direction.";
+    }
+    identity severelyErroredSecondsTCM6-down {
+        base performance-measurement-type-id;
+        description
+          "severely Errored Seconds Count on TCM6 down direction.";
+    }
+    identity unavailableSecondsTCM1-down {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM1 down direction.";
+    }
+    identity unavailableSecondsTCM2-down {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM2 down direction.";
+    }
+    identity unavailableSecondsTCM3-down {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM3 down direction.";
+    }
+    identity unavailableSecondsTCM4-down {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM4 down direction.";
+    }
+    identity unavailableSecondsTCM5-down {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM5 down direction.";
+    }
+    identity unavailableSecondsTCM6-down {
+        base performance-measurement-type-id;
+        description
+          "unavailable Seconds Count on TCM6 down direction.";
+    }
+    identity fecCorrectedCodewords {
+        base performance-measurement-type-id;
+        description
+          "FEC Corrected Codewords Counter";
+    }
+    identity fecUncorrectedCodewords {
+        base performance-measurement-type-id;
+        description
+          "FEC Uncorrected Codewords Counter";
+    }
+    identity fecSymbolErrors {
+        base performance-measurement-type-id;
+        description
+          "FEC Symbol Error Counter";
+    }
+    identity localFaultSeconds {
+        base performance-measurement-type-id;
+        description
+          "Local Fault Seconds";
+    }
+    identity remoteFaultSeconds {
+        base performance-measurement-type-id;
+        description
+          "Remote Fault Seconds";
+    }
+}
diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-units.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-units.yang
new file mode 100644
index 000000000..e8979396f
--- /dev/null
+++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-units.yang
@@ -0,0 +1,86 @@
+module data-provider-units {
+
+    yang-version 1.1;
+    namespace "urn:opendaylight:params:xml:ns:yang:data-provider-units";
+    prefix unit;
+
+    import data-provider-v2 {
+        prefix uxp;
+    }
+
+    organization
+      "highstreet technologies GmbH";
+    contact
+      "Web:   <https://highstreet-technologies.com>
+       ONAP:  <https://wiki.onap.org/display/DW/ODLUX+DB+API>";
+
+    description
+      "This module defines the unit names.
+       
+       Copyright 2020 highstreet technologies GmbH Intellectual Property.
+       All rights reserved.
+       
+       Licensed under the Apache License, Version 2.0 (the 'License');
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+       
+         http://www.apache.org/licenses/LICENSE-2.0
+       
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an 'AS IS' BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.";
+
+    revision 2020-04-13 {
+        description
+          "Initial revision";
+        reference
+          "ITU T-REC-G.826 2002-12";
+    }
+
+    // --- typedef
+    identity performance-measurement-unit-id {
+        base uxp:performance-measurement-unit-id;
+        description
+          "An abstract base performance measurement type which must not be 
+           used as reference in data objects.";
+    }
+
+    identity celsius {
+        base "performance-measurement-unit-id";
+        description
+          "°C: Grad Felsius";
+    }
+
+    identity dBm {
+        base "performance-measurement-unit-id";
+        description
+          "dBm is unit of level used to indicate that a power ratio is expressed in 
+           decibels (dB) with reference to one milliwatt (mW).";
+    }
+
+    identity dB {
+        base "performance-measurement-unit-id";
+        description
+          "dB: decibels";
+    }
+
+    identity fahrenheit {
+        base "performance-measurement-unit-id";
+        description
+          "°F: Grad Fahrenheit";
+    }
+
+    identity mW {
+        base "performance-measurement-unit-id";
+        description
+          "mW: milliwatt";
+    }
+
+    identity kHz {
+        base "performance-measurement-unit-id";
+        description
+          "kHz: kiloherz";
+    }
+}
diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-v2@2020-07-02.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-v2@2020-07-02.yang
new file mode 100644
index 000000000..358e30c8b
--- /dev/null
+++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-v2@2020-07-02.yang
@@ -0,0 +1,1748 @@
+module data-provider-v2 {
+  
+  yang-version 1.1;
+  namespace "urn:opendaylight:params:xml:ns:yang:data-provider-v2";
+  prefix odluxprovider;
+
+  import org-openroadm-pm-types {
+    prefix org-openroadm-pm-types;
+    reference
+      "OpenROADM: YANG definitions of performance management types";
+  }
+
+  import ietf-yang-types {
+    prefix yang;
+    reference
+      "RFC 6991: Common YANG Data Types.";
+  }
+
+  organization
+    "highstreet technologies GmbH";
+  contact
+    "Web:   <https://highstreet-technologies.com>
+     ONAP:  <https://wiki.onap.org/display/DW/ODLUX+DB+API>";
+
+  description
+    "This module defines the API for the data-provider component.
+
+     Copyright 2019 highstreet technologies GmbH Intellectual Property.
+     All rights reserved.
+
+     Licensed under the Apache License, Version 2.0 (the 'License');
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an 'AS IS' BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.";
+
+  revision 2020-07-02 {
+    description
+      "Initial revision";
+    reference
+      "https://jira.onap.org/browse/SDNC-xxx";
+  }
+
+  // --- typedef
+
+  typedef Entity {
+    type enumeration {
+      enum connectionlog {
+        description
+          "logs mountpoint connection state changes";
+      }
+      enum faultcurrent {
+        description
+          "current faults";
+      }
+      enum eventlog {
+        description
+          "logs for all notifications e.g. NetConf, ves and internal events";
+      }
+      enum faultlog {
+        description
+          "faultlog information";
+      }
+      enum historicalperformance15min {
+        description
+          "performance data";
+      }
+      enum historicalperformance24h {
+        description
+          "performance data";
+      }
+      enum mediator-server {
+        description
+          "list of mediator servers";
+      }
+      enum networkelement-connection {
+        description
+          "list of mountpoints for NetConf devices (joint required-network-element+mdsal
+              state";
+      }
+      enum inventoryequipment {
+        description
+          "list of equipment inventory";
+      }
+      enum maintenancemode {
+        description
+          "list of maintenance setting";
+      }
+    }
+    description
+      "Data type and alias for elasticsearch or table name for SQL database.";
+  }
+
+  typedef SortOrder {
+    type enumeration {
+      enum ascending {
+        description
+          "Self explaining.";
+      }
+      enum descending {
+        description
+          "Self explaining.";
+      }
+    }
+    description
+      "Entities for odlux clients";
+  }
+
+  typedef FilterProperty {
+    type string;
+    description
+      "A string type describing a property (attribute, column, parameter)
+       filter";
+  }
+
+  typedef NotificationType {
+    type enumeration {
+      enum ProblemNotificationXml {
+        description
+          "A fault (alarm, problem) notification type in XML format.";
+      }
+      enum AttributeValueChangedNotificationXml {
+        description
+          "An attribute value change notification type in XML format.";
+      }
+    }
+    description
+      "An enumeration describing the found notification type.";
+  }
+
+  typedef ConnectionLogStatus {
+    type enumeration {
+      enum Mounted {
+        description
+          "Mountpoint created";
+      }
+      enum Unmounted {
+        description
+          "Mountpoint removed";
+      }
+      enum Connecting {
+        description
+          "Mountpoint establishing connection";
+      }
+      enum Connected {
+        description
+          "Mountpoint connection established";
+      }
+      enum UnableToConnect {
+        description
+          "Mountpoint connection not possible";
+      }
+      enum Disconnected {
+        description
+          "Required and mountpoint removed";
+      }
+      enum Undefined {
+        description
+          "Status not available";
+      }
+    }
+    description
+      "An enumeration describing connection states.";
+  }
+
+  typedef NetworkElementDeviceType {
+    type enumeration {
+      enum Wireless {
+        description
+          "implements microwave-model.yang or air-interface.yang";
+      }
+      enum RAN {
+        description
+          "implements sth. like o-ran*.yang";
+      }
+      enum ORAN {
+        description
+          "implements RAN according to o-ran*.yang";
+      }
+      enum RAN3GPP {
+        description
+          "implements RAN according to _3gpp-ran*.yang";
+      }
+      enum Optical {
+        description
+          "implements tapi-*.yang or org-openroadm*.yang";
+      }
+      enum Router {
+        description
+          "implements vlan-interface.yang";
+      }
+      enum NtsManager {
+        description
+          "Simulation of device";
+      }
+      enum Nonsupported {
+        description
+          "Device type known, but not support";
+      }
+      enum Unknown {
+        description
+          "Device type at this point of time unknown";
+      }
+    }
+    description
+      "An enumeration as identification of the device.";
+  }
+
+  typedef severity-type {
+    type enumeration {
+      enum NonAlarmed {
+        description
+          "problem cleared indication";
+      }
+      enum Warning {
+        description
+          "problem level";
+      }
+      enum Minor {
+        description
+          "problem level";
+      }
+      enum Major {
+        description
+          "problem level";
+      }
+      enum Critical {
+        description
+          "problem level";
+      }
+    }
+    description
+      "According to ITU-T M.3160";
+  }
+
+  typedef source-type {
+    type enumeration {
+      enum Ves {
+        description
+          "VES Interface";
+      }
+      enum Netconf {
+        description
+          "NetConf Interface";
+      }
+      enum Controller {
+        description
+          "SDN Controller";
+      }
+      enum Unknown {
+        description
+          "Unknown source";
+      }
+    }
+    description
+      "An enumeration for the information source of an event/notification.";
+  }
+
+  typedef granularity-period-type {
+    type enumeration {
+      enum unknown {
+        description
+          "none";
+      }
+      enum period-15-min {
+        description
+          "none";
+      }
+      enum period-24-hours {
+        description
+          "none";
+      }
+    }
+    description
+      "The enumeration with the options for granularity period of the 
+       performance data similar to g.874.1-model";
+  }
+
+  // --- grouping and builder-container
+
+  grouping connectionlog-entity {
+    leaf id {
+      type string;
+      description
+        "database id";
+    }
+    leaf node-id {
+      type string;
+      description
+        "the node/mountpoint which connection state has changed";
+    }
+    leaf timestamp {
+      type yang:date-and-time;
+      description
+        "timestamp when event happened, preferred in UTC time format.";
+    }
+    leaf status {
+      type ConnectionLogStatus;
+      description
+        "new state of the connection of the device";
+    }
+    description
+      "An object class describing an entry in the connection status log.";
+  }
+
+  container connectionlog {
+    description
+      "builder";
+    uses connectionlog-entity;
+  }
+
+  grouping object-change-reference {
+    description
+      "Reference of of object (e.g. Interface pack) owned by a node";
+    leaf node-id {
+      type string;
+      description
+        "A network wide unique identifier of the NetConf server.";
+    }
+    leaf counter {
+      type int32;
+      description
+        "An arbitrary counter value.";
+    }
+    leaf timestamp {
+      type yang:date-and-time;
+      description
+        "The time of the reported change, preferred in UTC time format. ";
+    }
+    leaf object-id {
+      type string;
+      description
+        "The identifier of the reporting object (resource).";
+    }
+  }
+
+  grouping source-reference {
+    description
+      "Identify a source";
+    leaf source-type {
+      type source-type;
+      description
+        "The source type.";
+    }
+  }
+
+  grouping fault {
+    description
+      "Fault event of an object";
+    leaf problem {
+      type string;
+      description
+        "The alarm type identifier.";
+    }
+    leaf severity {
+      type severity-type;
+      description
+        "The reported severity of the fault (alarm).";
+    }
+  }
+
+  grouping attribute-change {
+    description
+      "update change of an attribute";
+    leaf attribute-name {
+      type string;
+      description
+        "The attribute name which was changed.";
+    }
+    leaf new-value {
+      type string;
+      description
+        "The new value of the attribute converted to a string format.";
+    }
+  }
+
+  grouping entity-id {
+    description
+      "Unique database id of entity";
+    leaf id {
+      type string;
+      description
+        "The unique identifier of the entity.";
+    }
+  }
+
+  grouping faultcurrent-entity {
+    description
+      "Current fault status";
+    uses object-change-reference;
+    uses fault;
+    uses entity-id;
+  }
+
+  container faultcurrent {
+    description
+      "builder";
+    uses faultcurrent-entity;
+  }
+
+  grouping faultlog-entity {
+    description
+      "Changed fault indication";
+    uses source-reference;
+    uses object-change-reference;
+    uses fault;
+    uses entity-id;
+  }
+
+  container faultlog {
+    description
+      "builder";
+    uses faultlog-entity;
+  }
+
+  grouping eventlog-entity {
+    description
+      "One change event of devices";
+    uses source-reference;
+    uses object-change-reference;
+    uses attribute-change;
+    uses entity-id;
+  }
+
+  container eventlog {
+    description
+      "builder";
+    uses eventlog-entity;
+  }
+
+  grouping filter {
+    leaf description {
+      type string;
+      description
+        "Filter specific description";
+    }
+    leaf start {
+      type yang:date-and-time;
+      description
+        "begin of maintenance-mode";
+    }
+    leaf end {
+      type yang:date-and-time;
+      description
+        "end of maintenance-mode";
+    }
+    leaf object-id-ref {
+      type string;
+      description
+        "object id to filter on, or empty for all";
+    }
+    leaf problem {
+      type string;
+      description
+        "name of the problem to filter or empty for all";
+    }
+    description
+      "An object class describing a generic filter of an interval for
+       faults (alarms).";
+  }
+
+  grouping maintenance-entity {
+    description
+      "Maintenance mode for a device. ";
+    leaf id {
+      type string;
+      mandatory true;
+      description
+        "Key to get/set configuration entry in database. Normally Mountpoint 
+         name is used as key id of node.";
+    }
+    leaf node-id {
+      type string;
+      mandatory true;
+      description
+        "A network wide unique identifier of the NetConf server.";
+    }
+    leaf active {
+      type boolean;
+      description
+        "Configuration to activate or deactivate this entry";
+    }
+    uses filter;
+  }
+
+  container maintenance {
+    presence "false";
+    description
+      "builder";
+    uses maintenance-entity;
+  }
+
+  grouping mediator-server-entity {
+    leaf id {
+      type string;
+      mandatory true;
+      description
+        "A network unique identifier of the mediator server.";
+    }
+    leaf url {
+      type string;
+      description
+        "The ULR to reach the REST interface of the mediator server.";
+    }
+    leaf name {
+      type string;
+      description
+        "A human readable name of the mediator server.";
+    }
+    description
+      "An object class describing a mediator server entity.";
+  }
+
+  grouping pmdata-base {
+    description
+      "Performance data base information";
+    leaf node-name {
+      type string;
+      description
+        "A network unique identifier of reporting NetConf server.";
+    }
+    leaf uuid-interface {
+      type string;
+      description
+        "A universal unique identifier of the performance monitoring point.";
+    }
+    leaf layer-protocol-name {
+      type string;
+      description
+        "The name of the measured transport layer.";
+    }
+    leaf radio-signal-id {
+      type string;
+      description
+        "The value exists only of wireless transport devices.";
+    }
+    leaf time-stamp {
+      type yang:date-and-time;
+      description
+        "The time-stamp of the measurement, preferred in UTC format.";
+    }
+    leaf suspect-interval-flag {
+      type boolean;
+      description
+        "If false, the measurement is not completed and should not be used
+         for performance analysis. ";
+    }
+    leaf granularity-period {
+      type granularity-period-type;
+      description
+        "The expected measurement interval.";
+    }
+    leaf scanner-id {
+      type string;
+      description
+        "See ITU-T X.739 chapter 8.1.1.2.";
+    }
+  }
+
+  grouping pmdata-microwave {
+    description
+      "Consolidated performance information of all microwave model interface 
+       PACs";
+    leaf es {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "Number of errored seconds.";
+    }
+    leaf ses {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "Number of severely errored seconds.";
+    }
+    leaf cses {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "Number of consecutive severely errored seconds.";
+    }
+    leaf unavailability {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "Total time of unavailability in seconds.";
+    }
+    leaf tx-level-min {
+      type int8;
+      units "dBm";
+      default "99";
+      config false;
+      description
+        "Minimum transmit power. Signed integers are required.";
+    }
+    leaf tx-level-max {
+      type int8;
+      units "dBm";
+      default "99";
+      config false;
+      description
+        "Maximum transmit power. Signed integers are required.";
+    }
+    leaf tx-level-avg {
+      type int8;
+      units "dBm";
+      default "99";
+      config false;
+      description
+        "Averaged transmit power. Signed integers are required.";
+    }
+    leaf rx-level-min {
+      type int8;
+      units "dBm";
+      default "99";
+      config false;
+      description
+        "Minimum receive level. Signed integers are required.";
+    }
+    leaf rx-level-max {
+      type int8;
+      units "dBm";
+      default "99";
+      config false;
+      description
+        "Maximum receive level. Signed integers are required.";
+    }
+    leaf rx-level-avg {
+      type int8;
+      units "dBm";
+      default "99";
+      config false;
+      description
+        "Averaged receive level. Signed integers are required.";
+    }
+    leaf time2-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "Sum of all seconds the transmitter operated in e.g. BPSK.";
+    }
+    leaf time4-states-s {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time4-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time8-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time16-states-s {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time16-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time32-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time64-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time128-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time256-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time512-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time512-states-l {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time1024-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time1024-states-l {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time2048-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time2048-states-l {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time4096-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time4096-states-l {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time8192-states {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf time8192-states-l {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "none";
+    }
+    leaf snir-min {
+      type int8;
+      units "dB";
+      default "-99";
+      config false;
+      description
+        "Minimum signal to (noise+interference) ratio.";
+    }
+    leaf snir-max {
+      type int8;
+      units "dB";
+      default "-99";
+      config false;
+      description
+        "Maximum signal to (noise+interference) ratio.";
+    }
+    leaf snir-avg {
+      type int8;
+      units "dB";
+      default "-99";
+      config false;
+      description
+        "Averaged signal to (noise+interference) ratio.";
+    }
+    leaf xpd-min {
+      type int8;
+      units "dB";
+      default "-99";
+      config false;
+      description
+        "Minimum cross polarization discrimination.";
+    }
+    leaf xpd-max {
+      type int8;
+      units "dB";
+      default "-99";
+      config false;
+      description
+        "Maximum cross polarization discrimination.";
+    }
+    leaf xpd-avg {
+      type int8;
+      units "dB";
+      default "-99";
+      config false;
+      description
+        "Averaged cross polarization discrimination.";
+    }
+    leaf rf-temp-min {
+      type int8;
+      units "C";
+      default "-99";
+      config false;
+      description
+        "Lowest temperature (in degree Celsius) of the radio module inside the 
+         outdoor unit.";
+    }
+    leaf rf-temp-max {
+      type int8;
+      units "C";
+      default "-99";
+      config false;
+      description
+        "Highest temperature (in degree Celsius) of the radio module inside the 
+         outdoor unit.";
+    }
+    leaf rf-temp-avg {
+      type int8;
+      units "C";
+      default "-99";
+      config false;
+      description
+        "Averaged temperature (in degree Celsius) of the radio module inside 
+         the outdoor unit.";
+    }
+    leaf defect-blocks-sum {
+      type int16;
+      units "blocks";
+      default "-1";
+      config false;
+      description
+        "Total number of blocks that were defect after receiving and could not 
+         be corrected by the FEC.";
+    }
+    leaf time-period {
+      type int32;
+      units "s";
+      default "-1";
+      config false;
+      description
+        "Total length of the measurement period.";
+    }
+  }
+
+  grouping pmdata-ethernet {
+    description
+      "Consolidated performance information for Ethernet.";
+    leaf tx-ethernet-bytes-max-s {
+      type int32;
+      units "Bytes/s";
+      default "-1";
+      config false;
+      description
+        "Counts the number of Bytes of Ethernet traffic (before header 
+         compression) transmitted within a second and keeps the highest value 
+         within the measurement period. Field to be left blank for all types of 
+         TDM containers.";
+    }
+    leaf tx-ethernet-bytes-max-m {
+      type int64;
+      units "Bytes/min";
+      default "-1";
+      config false;
+      description
+        "Counts the number of Bytes of Ethernet traffic (before header 
+         compression) transmitted within a minute and keeps the highest value 
+         with in the measurement period. Field to be left blank for all types 
+         of TDM containers.";
+    }
+    leaf tx-ethernet-bytes-sum {
+      type int64;
+      units "Bytes";
+      default "-1";
+      config false;
+      description
+        "Total number of Bytes of Ethernet traffic (before header compression) 
+         transmitted (in direction out of the device) during the measurement 
+        period. Field to be left blank for all types of TDM containers.";
+    }
+  }
+
+  identity performance-measurement-type-id {
+    description
+      "Base identity for perforamnce measurement types. A unique identification 
+       of the performance measurment value, not including the resource. 
+       Different resources can share performance measuement types. If the 
+       resource reports the same performance measurment type, it is to be 
+       considered to be the same performance measurment. 
+
+       This identity is abstract and MUST NOT be used for performence 
+       mesurement.";
+  }
+
+  identity performance-measurement-unit-id {
+    description
+      "Base identity for perforamnce measurement units. 
+
+       This identity is abstract and MUST NOT be used for performence 
+       mesurement.";
+  }
+
+  typedef performance-measurement-type-id {
+    type identityref {
+      base performance-measurement-type-id;
+    }
+    description
+      "Identifies an performance-measurement type. The description of the 
+       performance measurement type id MUST indicate if the performance 
+       measurement type is abstract or not. An abstract performance measurement 
+       type is used as a base for other performance measurement type ids
+       and will not be used as a value for an performance measurement or be 
+       present in the performance measurement inventory.";
+  }
+
+  typedef performance-measurement-unit-id {
+    type identityref {
+      base performance-measurement-unit-id;
+    }
+    description
+      "Identifies an performance-measurement unit. The description of the 
+       performance measurement unit id MUST indicate if the performance 
+       measurement unit is abstract or not. An abstract performance measurement 
+       unit is used as a base for other performance measurement unit ids
+       and will not be used as a value for an performance measurement or be 
+       present in the performance measurement inventory.";
+  }
+
+  grouping pm-measurement-grp {
+    leaf pm-key {
+      type performance-measurement-type-id;
+      description
+        "The local identifier of a pm-measurement object.";
+    }
+    leaf pm-value {
+      type org-openroadm-pm-types:pm-data-type;
+      mandatory true;
+      description
+        "The performance measurement value, measured in a certain interval.";
+    }
+    leaf pm-unit {
+      type performance-measurement-unit-id;
+      description
+        "A represention of the unit og the pm-value.";
+    }
+    description 
+      "An abstract object class representing a key-value pair for 
+       pm-measurement.";
+  }
+  grouping pmdata-grp {
+    list measurement {
+      key pm-key;
+      uses pm-measurement-grp;
+      description 
+        "An abstract list of perfromance mesurement values.";
+    }
+    description 
+      "An abstract object class containing a list of perfromance mesurement 
+       values.";
+  }
+
+  container pmdata-entity {
+    description
+      "builder";
+    uses pmdata-base;
+    container performance-data {
+      uses pmdata-microwave;
+      uses pmdata-ethernet;
+      uses pmdata-grp;
+      description
+        "An object combining different performance monitoring data.";
+    }
+  }
+
+  grouping pmdata15m-entity {
+    uses pmdata-base;
+    container performance-data {
+      uses pmdata-microwave;
+      uses pmdata-ethernet;
+      description
+        "An object combining different performance monitoring data.";
+    }
+    description
+      "An object class describing a 15 minute performance monitoring entity.";
+  }
+
+  grouping pmdata24h-entity {
+    uses pmdata-base;
+    container performance-data {
+      uses pmdata-microwave;
+      uses pmdata-ethernet;
+      description
+        "An object combining different performance monitoring data.";
+    }
+    description
+      "An object class describing a 24 hour performance monitoring entity.";
+  }
+
+  grouping inventory-entity {
+    description
+      "One equipment entity in a list of a network element that could be rack, 
+       card, backplane, module";
+    leaf id {
+      type string;
+      mandatory true;
+      description
+        "Unique database id, node-id/uuid";
+    }
+    leaf tree-level {
+      type uint32;
+      description
+        "Containment level, starting with 0..";
+    }
+    leaf parent-uuid {
+      type string;
+      description
+        "Unique inventory id of holder";
+    }
+    leaf node-id {
+      type string;
+      description
+        "Unique node id of network element";
+    }
+    leaf uuid {
+      type string;
+      description
+        "Unique inventory id of this node for this equipment, provided by 
+         network element";
+    }
+    leaf-list contained-holder {
+      type string;
+      description
+        "List of uuid of contained equipment";
+    }
+    leaf manufacturer-name {
+      type string;
+      description
+        "manufactured-thing/manufacturer-properties/manufacturer-name";
+    }
+    leaf manufacturer-identifier {
+      type string;
+      description
+        "manufactured-thing/manufacturer-properties/manufacturer-identifier";
+    }
+    leaf serial {
+      type string;
+      description
+        "manufactured-thing/equipment-instance/serial";
+    }
+    leaf date {
+      type string;
+      description
+        "manufactured-thing/equipment-instance/manufacture-date: Date 
+         information provided by manufacturer. No specific format. ()";
+    }
+    leaf version {
+      type string;
+      description
+        "manufactured-thing/equipment-type/version";
+    }
+    leaf description {
+      type string;
+      description
+        "manufactured-thing/equipment-type/description";
+    }
+    leaf part-type-id {
+      type string;
+      description
+        "manufactured-thing/equipment-type/part-type-identifier";
+    }
+    leaf model-identifier {
+      type string;
+      description
+        "manufactured-thing/equipment-type/model-identifier";
+    }
+    leaf type-name {
+      type string;
+      description
+        "manufactured-thing/equipment-type/type-name";
+    }
+  }
+
+  container inventory {
+    presence "false";
+    description
+      "builder";
+    uses inventory-entity;
+  }
+
+  grouping node-details-g {
+    leaf-list available-capabilities {
+      type string;
+      description
+        "The list of available yang capabilities.";
+    }
+    leaf-list unavailable-capabilities {
+      type string;
+      description
+        "The list of unavailable yang capabilities.";
+    }
+    description
+      "An object class description the available and unavailable yang
+       capabilities.";
+  }
+
+  grouping network-element-connection-entity {
+    leaf id {
+      type string;
+      description
+        "database id/key. here is equal to node-id";
+    }
+    leaf node-id {
+      type string;
+      description
+        "mountpoint name of device in controller";
+    }
+    leaf host {
+      type string;
+      description
+        "NetConf server host name or IP address of device";
+    }
+    leaf port {
+      type uint32;
+      description
+        "NetConf port of device";
+    }
+    leaf username {
+      type string;
+      description
+        "NetConf user name";
+    }
+    leaf password {
+      type string;
+      description
+        "NetConf password. should be removed asap";
+    }
+    leaf core-model-capability {
+      type string;
+      description
+        "revision of core-model capability";
+    }
+    leaf device-type {
+      type NetworkElementDeviceType;
+      description
+        "categorized type of device based on implemented yang specs";
+    }
+    leaf is-required {
+      type boolean;
+      description
+        "entry exists in db index required-networkelement";
+    }
+    container node-details {
+      uses node-details-g;
+      description
+        "holder of available and unavailable capabilities";
+    }
+    leaf status {
+      type ConnectionLogStatus;
+      description
+        "current connection status. default Disconnected";
+    }
+    description
+      "An object class defining the NetConf connection towards a
+       NetConf server. ";
+  }
+
+  container network-element-connection {
+    description
+      "builder";
+    uses network-element-connection-entity;
+  }
+
+  grouping status-entity {
+    container faults {
+      leaf criticals {
+        type uint32;
+        description
+          "The number of current faults (active alarms) with severity
+           'critical'.";
+      }
+      leaf majors {
+        type uint32;
+        description
+          "The number of current faults (active alarms) with severity
+           'major'.";
+      }
+      leaf minors {
+        type uint32;
+        description
+          "The number of current faults (active alarms) with severity
+           'minor'.";
+      }
+      leaf warnings {
+        type uint32;
+        description
+          "The number of current faults (active alarms) with severity
+           'warning'.";
+      }
+      description
+        "An object containing the number of current faults per its severity.";
+    }
+    description
+      "An object class defining an status entity for current faults
+       (also called active alarms).";
+  }
+
+  container status {
+    description
+      "builder";
+    uses status-entity;
+  }
+
+  grouping entity-input {
+    list filter {
+      key "property";
+      leaf property {
+        type string;
+        description
+          "The property (parameter, column, field) identifier.";
+      }
+      leaf filtervalue {
+        type string;
+        description
+          "The filter information for the corresponding property.";
+      }
+      description
+        "List with filter criteria. Not listed means all.";
+    }
+    list sortorder {
+      key "property";
+      leaf property {
+        type string;
+        description
+          "The property (parameter, column, field) identifier.";
+      }
+      leaf sortorder {
+        type SortOrder;
+        description
+          "The definition of the sort order for the corresponding property.";
+      }
+      description
+        "List with sort order. Not listed means default";
+    }
+    container pagination {
+      leaf size {
+        type uint32 {
+          range "1..max";
+        }
+        default "20";
+        description
+          "Number of entries to be delivered";
+      }
+      leaf page {
+        type uint64 {
+          range "1..max";
+        }
+        default "1";
+        description
+          "Number to be used to calculate starting entry to deliver";
+      }
+      description
+        "An object defining the pagination details.";
+    }
+    description
+      "An object class defining a request input entity.";
+  }
+
+  grouping pagination-output-g {
+    leaf size {
+      type uint32 {
+        range "1..max";
+      }
+      default "20";
+      description
+        "Number of entries to be delivered";
+    }
+    leaf page {
+      type uint64 {
+        range "1..max";
+      }
+      default "1";
+      description
+        "Number to be used to calculate starting entry to deliver";
+    }
+    leaf total {
+      type uint64 {
+        range "0..max";
+      }
+      default "0";
+      description
+        "Number to be used to calculate starting entry to deliver";
+    }
+    description
+      "An object class defining the filter information for pagination.";
+  }
+
+  container pagination-output {
+    description
+      "builder";
+    uses pagination-output-g;
+  }
+
+  // --- rpc
+
+  rpc read-faultcurrent-list {
+    description
+      "Get list of current fault (active alarm) entries according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses faultcurrent-entity;
+        description
+          "The output data as list of current fault (or active alarm)
+           entities.";
+      }
+    }
+  }
+
+  rpc read-faultlog-list {
+    description
+      "Get list of faultlog entries according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses faultlog-entity;
+        description
+          "The output data as list of fault entities.";
+      }
+    }
+  }
+
+  rpc read-eventlog-list {
+    description
+      "Get list of event log entities according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses eventlog-entity;
+        description
+          "The output data as list of event log entities.";
+      }
+    }
+  }
+
+  rpc read-connectionlog-list {
+    description
+      "Get list of event log entities according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses connectionlog-entity;
+        description
+          "The output data as list of connection log entities.";
+      }
+    }
+  }
+
+  rpc read-maintenance-list {
+    description
+      "Get list of maintenance entries according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses maintenance-entity;
+        description
+          "The output data as list of maintenance entities.";
+      }
+    }
+  }
+
+  rpc create-maintenance {
+    description
+      "insert new entry of maintenance";
+    input {
+      uses maintenance-entity;
+    }
+    output {
+      uses maintenance-entity;
+    }
+  }
+
+  rpc update-maintenance {
+    description
+      "update existing entity of maintenance";
+    input {
+      uses maintenance-entity;
+    }
+    output {
+      uses maintenance-entity;
+    }
+  }
+
+  rpc delete-maintenance {
+    description
+      "delete entity of maintenance";
+    input {
+      uses maintenance-entity;
+    }
+  }
+
+  rpc read-mediator-server-list {
+    description
+      "Get list of mediator-servers according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses mediator-server-entity;
+        description
+          "The list of found mediator server entities.";
+      }
+    }
+  }
+
+  rpc create-mediator-server {
+    description
+      "create new entry of entity mediator-server";
+    input {
+      uses mediator-server-entity;
+    }
+    output {
+      uses mediator-server-entity;
+    }
+  }
+
+  rpc update-mediator-server {
+    description
+      "update entry of entity mediator-server";
+    input {
+      uses mediator-server-entity;
+    }
+    output {
+      uses mediator-server-entity;
+    }
+  }
+
+  rpc delete-mediator-server {
+    description
+      "delete entry of entity mediator-server";
+    input {
+      uses mediator-server-entity;
+    }
+  }
+
+  rpc read-network-element-connection-list {
+    description
+      "Get list of networkelement-connections according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses network-element-connection-entity;
+        description
+          "The output data as list of found network-element (or mountpoint,
+           or network functions) connection entities.";
+      }
+    }
+  }
+
+  rpc create-network-element-connection {
+    description
+      "create entry in networkelement-connection";
+    input {
+      uses network-element-connection-entity;
+    }
+    output {
+      uses network-element-connection-entity;
+    }
+  }
+
+  rpc update-network-element-connection {
+    description
+      "Put an element to ne-entity";
+    input {
+      uses network-element-connection-entity;
+    }
+    output {
+      uses network-element-connection-entity;
+    }
+  }
+
+  rpc delete-network-element-connection {
+    description
+      "!ONLY FOR TESTING! Put an element to ne-entity";
+    input {
+      uses network-element-connection-entity;
+    }
+  }
+
+  rpc read-pmdata-15m-ltp-list {
+    description
+      "Get list of ltps for one mountpoint with historical pmdata";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      leaf-list data {
+        type string;
+        description
+          "The list of found mountpoint names.";
+      }
+    }
+  }
+
+  rpc read-pmdata-24h-ltp-list {
+    description
+      "Get list of ltps for one mountpoint with historical pmdata";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      leaf-list data {
+        type string;
+        description
+          "The list of found logical-termination-point identifiers.";
+      }
+    }
+  }
+
+  rpc read-pmdata-15m-device-list {
+    description
+      "Get list of mountpoints with historical pmdata";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      leaf-list data {
+        type string;
+        description
+          "The list of found mountpoint names.";
+      }
+    }
+  }
+
+  rpc read-pmdata-24h-device-list {
+    description
+      "Get list of mountpoints with historical pmdata";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      leaf-list data {
+        type string;
+        description
+          "The list of found mountpoint names.";
+      }
+    }
+  }
+
+  rpc read-pmdata-15m-list {
+    description
+      "Get list of entities according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses pmdata15m-entity;
+        description
+          "The output data as list of 15 minutes performance monitoring
+           entities.";
+      }
+    }
+  }
+
+  rpc read-pmdata-24h-list {
+    description
+      "Get list of historical pmdata according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses pmdata24h-entity;
+        description
+          "The output data as list of 24 hours performance monitoring
+           entities.";
+      }
+    }
+  }
+
+  rpc read-inventory-list {
+    description
+      "Get list of inventory according to filter";
+    input {
+      uses entity-input;
+    }
+    output {
+      container pagination {
+        uses pagination-output-g;
+        description
+          "The pagination details used by the provider to filter the data.";
+      }
+      list data {
+        uses inventory-entity;
+        description
+          "The output data as list of inventory entities.";
+      }
+    }
+  }
+
+  rpc read-status {
+    description
+      "Read status information of controller";
+    output {
+      list data {
+        uses status-entity;
+        description
+          "The output data as list of status entities.";
+      }
+    }
+  }
+}
diff --git a/sdnr/wt/data-provider/model/src/main/yang/org-openroadm-pm-types@2020-03-27.yang b/sdnr/wt/data-provider/model/src/main/yang/org-openroadm-pm-types@2020-03-27.yang
new file mode 100644
index 000000000..1fbd72e0f
--- /dev/null
+++ b/sdnr/wt/data-provider/model/src/main/yang/org-openroadm-pm-types@2020-03-27.yang
@@ -0,0 +1,709 @@
+module org-openroadm-pm-types {
+  namespace "http://org/openroadm/pm-types";
+  prefix org-openroadm-pm-types;
+
+  organization
+    "Open ROADM MSA";
+  contact
+    "OpenROADM.org";
+  description
+    "YANG definitions of performance management types.
+
+      Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+      All other rights reserved.
+
+      Redistribution and use in source and binary forms, with or without modification,
+      are permitted provided that the following conditions are met:
+
+      * Redistributions of source code must retain the above copyright notice, this
+        list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright notice,
+        this list of conditions and the following disclaimer in the documentation and/or
+        other materials provided with the distribution.
+      * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+        contributors may be used to endorse or promote products derived from this software
+        without specific prior written permission.
+
+      THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA  AGREEMENT ''AS IS''
+      AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+      WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+      IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA  AGREEMENT BE LIABLE FOR ANY DIRECT,
+      INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+      NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE, DATA,
+      OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+      WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+      ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+      POSSIBILITY OF SUCH DAMAGE";
+
+  revision 2020-03-27 {
+    description
+      "Version 7.0.0";
+  }
+  revision 2019-11-29 {
+    description
+      "Version 6.1.0";
+  }
+  revision 2019-03-29 {
+    description
+      "Version 5.0.0";
+  }
+  revision 2018-11-30 {
+    description
+      "Version 4.1.0";
+  }
+  revision 2017-12-15 {
+    description
+      "Version 2.2";
+  }
+  revision 2017-09-29 {
+    description
+      "Version 2.1";
+  }
+  revision 2017-06-26 {
+    description
+      "Version 2.0";
+  }
+  revision 2016-10-14 {
+    description
+      "Version 1.2";
+  }
+
+  typedef pm-granularity {
+    type enumeration {
+      enum notApplicable {
+        value 1;
+        description
+          "This is for total statistic counters on devices that support
+              them.";
+      }
+      enum 15min {
+        value 2;
+      }
+      enum 24Hour {
+        value 3;
+      }
+    }
+    description
+      "Granularity of PM bin";
+  }
+
+  typedef pm-data-type {
+    type union {
+      type uint64;
+      type int64;
+      type decimal64 {
+        fraction-digits 2;
+      }
+      type decimal64 {
+        fraction-digits 17;
+      }
+    }
+  }
+
+  typedef validity {
+    type enumeration {
+      enum complete {
+        value 1;
+      }
+      enum partial {
+        value 2;
+      }
+      enum suspect {
+        value 3;
+      }
+    }
+    description
+      "Validity of data";
+  }
+
+  typedef pm-names-enum {
+    type enumeration {
+      enum vendorExtension {
+        value 1;
+        description
+          "vendor extension";
+      }
+      enum bitErrorRate {
+        value 2;
+        description
+          "Bit error rate (BER)";
+      }
+      enum opticalPowerOutput {
+        value 3;
+        description
+          "Optical Power Output (OPOUT-OTS, OPOUT-OMS, OPT-OCH). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+      }
+      enum opticalReturnLoss {
+        value 4;
+        description
+          "Optical Return Loss (ORL-OTS) - at MW port(s) B";
+      }
+      enum opticalPowerInput {
+        value 5;
+        description
+          "Optical Power Input (OPIN-OTS, OPIN-OMS, OPR-OCH). Total optical power";
+      }
+      enum codeViolations {
+        value 8;
+        description
+          "Code Violations (CV)";
+      }
+      enum erroredSeconds {
+        value 9;
+        description
+          "Errored Seconds (ES)";
+      }
+      enum severelyErroredSeconds {
+        value 10;
+        description
+          "Severely Errored Seconds (SES)";
+      }
+      enum unavailableSeconds {
+        value 11;
+        description
+          "Unavailable Seconds (UAS)";
+      }
+      enum inFrames {
+        value 12;
+        description
+          "In frames (INFRAMES-E)";
+      }
+      enum inFramesErrored {
+        value 13;
+        description
+          "In frames errored (INFRAMESERR-E)";
+      }
+      enum outFrames {
+        value 14;
+        description
+          "Out frames (OUTFRAMES-E)";
+      }
+      enum erroredSecondsEthernet {
+        value 15;
+        description
+          "Errored Seconds Ethernet (ES-E)";
+      }
+      enum severelyErroredSecondsEthernet {
+        value 16;
+        description
+          "Severely Errored Seconds, Ethernet (SES-E)";
+      }
+      enum unavailableSecondsEthernet {
+        value 17;
+        description
+          "Unavailable Seconds, Ethernet (UAS-E)";
+      }
+      enum erroredBlockCount {
+        value 18;
+        description
+          "Errored block count";
+      }
+      enum delay {
+        value 19;
+        description
+          "Number of frames between a DMValue toggle event and the received DMp signal value toggle event";
+      }
+      enum defectSeconds {
+        value 20;
+        description
+          "Defect Seconds (DS)";
+      }
+      enum backwardIncomingAlignmentError {
+        value 21;
+        description
+          "Backward Incoming Alignment Error (BIAE)";
+      }
+      enum incomingAlignmentError {
+        value 22;
+        description
+          "Incoming Alignment Error (IAE)";
+      }
+      enum opticalPowerOutputMin {
+        value 23;
+        description
+          "Minimum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+      }
+      enum opticalPowerOutputMax {
+        value 24;
+        description
+          "Maximum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+      }
+      enum opticalPowerOutputAvg {
+        value 25;
+        description
+          "Average Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+      }
+      enum opticalPowerInputMin {
+        value 26;
+        description
+          "Minimum Optical Power Input (OPIN-OTS). Total optical power";
+      }
+      enum opticalPowerInputMax {
+        value 27;
+        description
+          "Maximum Optical Power Input (OPIN-OTS). Total optical power";
+      }
+      enum opticalPowerInputAvg {
+        value 28;
+        description
+          "Average Optical Power Input (OPIN-OTS). Total optical power";
+      }
+      enum opticalPowerOutputOSC {
+        value 29;
+        description
+          "OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+      }
+      enum opticalPowerOutputOSCMin {
+        value 30;
+        description
+          "Minimum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+      }
+      enum opticalPowerOutputOSCMax {
+        value 31;
+        description
+          "Maximum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+      }
+      enum opticalPowerOutputOSCAvg {
+        value 32;
+        description
+          "Average OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port";
+      }
+      enum opticalPowerInputOSC {
+        value 33;
+        description
+          "OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+      }
+      enum opticalPowerInputOSCMin {
+        value 34;
+        description
+          "Minimum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+      }
+      enum opticalPowerInputOSCMax {
+        value 35;
+        description
+          "Maximum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+      }
+      enum opticalPowerInputOSCAvg {
+        value 36;
+        description
+          "Average OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port";
+      }
+      enum preFECCorrectedErrors {
+        value 37;
+        description
+          "pFEC corrected Errors";
+      }
+      enum totalOpticalPowerInput {
+        value 38;
+        description
+          "Total Optical Power Input.";
+      }
+      enum totalOpticalPowerInputMin {
+        value 39;
+        description
+          "Minimum Total Optical Power Input.";
+      }
+      enum totalOpticalPowerInputMax {
+        value 40;
+        description
+          "Maximum Total Optical Power Input.";
+      }
+      enum totalOpticalPowerInputAvg {
+        value 41;
+        description
+          "Average Total Optical Power Input.";
+      }
+      enum FECCorrectableBlocks {
+        value 42;
+        description
+          "FEC Correctable Blocks.";
+      }
+      enum FECUncorrectableBlocks {
+        value 43;
+        description
+          "FEC Uncorrectable Blocks.";
+      }
+      enum BIPErrorCounter {
+        value 56;
+        description
+          "BIP Error Counter";
+      }
+      enum protectionSwitchingCount {
+        value 57;
+        description
+          "Protection Switching Count (PSC)";
+      }
+      enum protectionSwitchingDuration {
+        value 58;
+        description
+          "Protection Switching Duration in seconds (PSD)";
+      }
+      enum erroredBlockCountTCM1-up {
+        value 59;
+        description
+          "errored Blocks Count on TCM1 up direction.";
+      }
+      enum erroredBlockCountTCM2-up {
+        value 60;
+        description
+          "errored Blocks Count on TCM2 up direction.";
+      }
+      enum erroredBlockCountTCM3-up {
+        value 61;
+        description
+          "errored Blocks Count on TCM3 up direction.";
+      }
+      enum erroredBlockCountTCM4-up {
+        value 62;
+        description
+          "errored Blocks Count on TCM4 up direction.";
+      }
+      enum erroredBlockCountTCM5-up {
+        value 63;
+        description
+          "errored Blocks Count on TCM5 up direction.";
+      }
+      enum erroredBlockCountTCM6-up {
+        value 64;
+        description
+          "errored Blocks Count on TCM6 up direction.";
+      }
+      enum delayTCM1-up {
+        value 65;
+        description
+          "Delay on TCM1 up direction.";
+      }
+      enum delayTCM2-up {
+        value 66;
+        description
+          "Delay on TCM2 up direction.";
+      }
+      enum delayTCM3-up {
+        value 67;
+        description
+          "Delay on TCM3 up direction.";
+      }
+      enum delayTCM4-up {
+        value 68;
+        description
+          "Delay on TCM4 up direction.";
+      }
+      enum delayTCM5-up {
+        value 69;
+        description
+          "Delay on TCM5 up direction.";
+      }
+      enum delayTCM6-up {
+        value 70;
+        description
+          "Delay on TCM6 up direction.";
+      }
+      enum erroredBlockCountTCM1-down {
+        value 71;
+        description
+          "errored Blocks Count on TCM1 down direction.";
+      }
+      enum erroredBlockCountTCM2-down {
+        value 72;
+        description
+          "errored Blocks Count on TCM2 down direction.";
+      }
+      enum erroredBlockCountTCM3-down {
+        value 73;
+        description
+          "errored Blocks Count on TCM3 down direction.";
+      }
+      enum erroredBlockCountTCM4-down {
+        value 74;
+        description
+          "errored Blocks Count on TCM4 down direction.";
+      }
+      enum erroredBlockCountTCM5-down {
+        value 75;
+        description
+          "errored Blocks Count on TCM5 down direction.";
+      }
+      enum erroredBlockCountTCM6-down {
+        value 76;
+        description
+          "errored Blocks Count on TCM6 down direction.";
+      }
+      enum delayTCM1-down {
+        value 77;
+        description
+          "Delay on TCM1 down direction.";
+      }
+      enum delayTCM2-down {
+        value 78;
+        description
+          "Delay on TCM2 down direction.";
+      }
+      enum delayTCM3-down {
+        value 79;
+        description
+          "Delay on TCM3 down direction.";
+      }
+      enum delayTCM4-down {
+        value 80;
+        description
+          "Delay on TCM4 down direction.";
+      }
+      enum delayTCM5-down {
+        value 81;
+        description
+          "Delay on TCM5 down direction.";
+      }
+      enum delayTCM6-down {
+        value 82;
+        description
+          "Delay on TCM6 down direction.";
+      }
+      enum partialRateDiscard {
+        value 83;
+        description
+          "Discarded packet as a result of policing or rate limiting for subrate ethernet.";
+      }
+      enum erroredSecondsTCM1-up {
+        value 84;
+        description
+          "errored Seconds Count on TCM1 up direction.";
+      }
+      enum erroredSecondsTCM2-up {
+        value 85;
+        description
+          "errored Seconds Count on TCM2 up direction.";
+      }
+      enum erroredSecondsTCM3-up {
+        value 86;
+        description
+          "errored Seconds Count on TCM3 up direction.";
+      }
+      enum erroredSecondsTCM4-up {
+        value 87;
+        description
+          "errored Seconds Count on TCM4 up direction.";
+      }
+      enum erroredSecondsTCM5-up {
+        value 88;
+        description
+          "errored Seconds Count on TCM5 up direction.";
+      }
+      enum erroredSecondsTCM6-up {
+        value 89;
+        description
+          "errored Seconds Count on TCM6 up direction.";
+      }
+      enum severelyErroredSecondsTCM1-up {
+        value 90;
+        description
+          "severely Errored Seconds Count on TCM1 up direction.";
+      }
+      enum severelyErroredSecondsTCM2-up {
+        value 91;
+        description
+          "severely Errored Seconds Count on TCM2 up direction.";
+      }
+      enum severelyErroredSecondsTCM3-up {
+        value 92;
+        description
+          "severely Errored Seconds Count on TCM3 up direction.";
+      }
+      enum severelyErroredSecondsTCM4-up {
+        value 93;
+        description
+          "severely Errored Seconds Count on TCM4 up direction.";
+      }
+      enum severelyErroredSecondsTCM5-up {
+        value 94;
+        description
+          "severely Errored Seconds Count on TCM5 up direction.";
+      }
+      enum severelyErroredSecondsTCM6-up {
+        value 95;
+        description
+          "severely Errored Seconds Count on TCM6 up direction.";
+      }
+      enum unavailableSecondsTCM1-up {
+        value 96;
+        description
+          "unavailable Seconds Count on TCM1 up direction.";
+      }
+      enum unavailableSecondsTCM2-up {
+        value 97;
+        description
+          "unavailable Seconds Count on TCM2 up direction.";
+      }
+      enum unavailableSecondsTCM3-up {
+        value 98;
+        description
+          "unavailable Seconds Count on TCM3 up direction.";
+      }
+      enum unavailableSecondsTCM4-up {
+        value 99;
+        description
+          "unavailable Seconds Count on TCM4 up direction.";
+      }
+      enum unavailableSecondsTCM5-up {
+        value 100;
+        description
+          "unavailable Seconds Count on TCM5 up direction.";
+      }
+      enum unavailableSecondsTCM6-up {
+        value 101;
+        description
+          "unavailable Seconds Count on TCM6 up direction.";
+      }
+      enum erroredSecondsTCM1-down {
+        value 102;
+        description
+          "errored Seconds Count on TCM1 down direction.";
+      }
+      enum erroredSecondsTCM2-down {
+        value 103;
+        description
+          "errored Seconds Count on TCM2 down direction.";
+      }
+      enum erroredSecondsTCM3-down {
+        value 104;
+        description
+          "errored Seconds Count on TCM3 down direction.";
+      }
+      enum erroredSecondsTCM4-down {
+        value 105;
+        description
+          "errored Seconds Count on TCM4 down direction.";
+      }
+      enum erroredSecondsTCM5-down {
+        value 106;
+        description
+          "errored Seconds Count on TCM5 down direction.";
+      }
+      enum erroredSecondsTCM6-down {
+        value 107;
+        description
+          "errored Seconds Count on TCM6 down direction.";
+      }
+      enum severelyErroredSecondsTCM1-down {
+        value 108;
+        description
+          "severely Errored Seconds Count on TCM1 down direction.";
+      }
+      enum severelyErroredSecondsTCM2-down {
+        value 109;
+        description
+          "severely Errored Seconds Count on TCM2 down direction.";
+      }
+      enum severelyErroredSecondsTCM3-down {
+        value 110;
+        description
+          "severely Errored Seconds Count on TCM3 down direction.";
+      }
+      enum severelyErroredSecondsTCM4-down {
+        value 111;
+        description
+          "severely Errored Seconds Count on TCM4 down direction.";
+      }
+      enum severelyErroredSecondsTCM5-down {
+        value 112;
+        description
+          "severely Errored Seconds Count on TCM5 down direction.";
+      }
+      enum severelyErroredSecondsTCM6-down {
+        value 113;
+        description
+          "severely Errored Seconds Count on TCM6 down direction.";
+      }
+      enum unavailableSecondsTCM1-down {
+        value 114;
+        description
+          "unavailable Seconds Count on TCM1 down direction.";
+      }
+      enum unavailableSecondsTCM2-down {
+        value 115;
+        description
+          "unavailable Seconds Count on TCM2 down direction.";
+      }
+      enum unavailableSecondsTCM3-down {
+        value 116;
+        description
+          "unavailable Seconds Count on TCM3 down direction.";
+      }
+      enum unavailableSecondsTCM4-down {
+        value 117;
+        description
+          "unavailable Seconds Count on TCM4 down direction.";
+      }
+      enum unavailableSecondsTCM5-down {
+        value 118;
+        description
+          "unavailable Seconds Count on TCM5 down direction.";
+      }
+      enum unavailableSecondsTCM6-down {
+        value 119;
+        description
+          "unavailable Seconds Count on TCM6 down direction.";
+      }
+      enum fecCorrectedCodewords {
+        value 120;
+        description
+          "FEC Corrected Codewords Counter";
+      }
+      enum fecUncorrectedCodewords {
+        value 121;
+        description
+          "FEC Uncorrected Codewords Counter";
+      }
+      enum fecSymbolErrors {
+        value 122;
+        description
+          "FEC Symbol Error Counter";
+      }
+      enum localFaultSeconds {
+        value 123;
+        description
+          "Local Fault Seconds";
+      }
+      enum remoteFaultSeconds {
+        value 124;
+        description
+          "Remote Fault Seconds";
+      }
+    }
+  }
+
+  grouping pm-measurement {
+    description
+      "Set of parameters related to a PM Measurement";
+    leaf pmParameterValue {
+      type pm-data-type;
+      config false;
+      mandatory true;
+    }
+    leaf pmParameterUnit {
+      type string;
+      mandatory false;
+      description
+        "Unit PM parameter has been measured - frames, packets, u, etc";
+    }
+    leaf validity {
+      type validity;
+      mandatory false;
+    }
+  }
+
+  grouping pm-names {
+    description
+      "Name of PM parameter. Consists of a set list of parameters,
+       plus an extension field to support addition parameters.";
+    leaf type {
+      type pm-names-enum;
+      mandatory true;
+    }
+    leaf extension {
+      type string;
+      description
+        "name of parameter, when enum value set to vendorExtension because
+         name not found in pm-names-enum";
+    }
+  }
+}
\ No newline at end of file
diff --git a/sdnr/wt/data-provider/provider/pom.xml b/sdnr/wt/data-provider/provider/pom.xml
index 335fd0c28..a536d64b1 100644
--- a/sdnr/wt/data-provider/provider/pom.xml
+++ b/sdnr/wt/data-provider/provider/pom.xml
@@ -48,10 +48,7 @@
 
     <properties>
         <maven.javadoc.skip>true</maven.javadoc.skip>
-        <maven.build.timestamp.format>yyyy-MM-dd HH:mm</maven.build.timestamp.format>
-        <buildtime>${maven.build.timestamp}</buildtime>
         <databaseport>49402</databaseport>
-        <odlux.buildno>56.139cd6d(20/07/08)</odlux.buildno>
     </properties>
 
     <dependencies>