module fujitsu-performance-monitoring {

    yang-version 1;

    namespace
      "urn:fujitsu:params:xml:ns:yang:perfmon";

    prefix perfmon;

    import ietf-yang-types {
      prefix yang;
    }
    import fujitsu-notifications {
      prefix notifications;
    }

    organization "Fujitsu Ltd.";

    contact
      "Fujitsu Ltd.
     
     Address: 2801 Telecom Parkway
              Richardson, Texas 75082
     
     Tel: +1-800-USE-FTAC (1-800-873-3822)
     Email: ftac@fnc.fujitsu.com
     Web: www.fujitsu.com/us/services/telecom";

    description
      "This module contains a collection of YANG definitions for
     Performance Monitoring management.
     
     Copyright (c) 2015 Fujitsu Ltd.
     All rights reserved. ";

    revision "2015-05-07" {
      description "Initial revision.";
    }

    revision "2016-12-07" {
      description
        "Corrected pm-validity description.";
    }


    identity performance-monitor-identity {
      description
        "Base identity for PM types. A unique identification of the PM
         identifier, not including the resource. A string-based qualifier
         can be used in addition to the identity in order to have different
         PM types based on information not known at design-time. Standards
         and vendors can define sub-identities to clearly identify specific
         PM types.";
    }

    typedef pm-identity {
      type identityref {
        base perfmon:performance-monitor-identity;
      }
      description "PM name";
    }

    typedef pm-location {
      type enumeration {
        enum "nearEnd" {
          value 0;
          description "Near-end location";
        }
        enum "farEnd" {
          value 1;
          description "Far-end location";
        }
      }
      description "PM location";
    }

    typedef pm-direction {
      type enumeration {
        enum "transmit" {
          value 0;
          description "Transmit direction";
        }
        enum "receive" {
          value 1;
          description "Receive direction";
        }
        enum "na" {
          value 2;
          description
            "Direction not applicable";
        }
      }
      description "PM direction";
    }

    typedef pm-type {
      type enumeration {
        enum "cumulative" {
          value 0;
          description "Cumulative PM type";
        }
        enum "metered" {
          value 1;
          description "Metered PM type";
        }
        enum "binned" {
          value 2;
          description "Binned PM type";
        }
      }
      description "PM type";
    }

    typedef pm-data-type {
      type union {
        type uint64;
        type int64;
        type decimal64 {
          fraction-digits 2;
        }
        type decimal64 {
          fraction-digits 17;
        }
      }
    }

    typedef pm-time-period {
      type enumeration {
        enum "cumulative" {
          value 0;
          description "cumulative";
        }
        enum "15-min" {
          value 1;
          description "15 minutes period";
        }
        enum "1-day" {
          value 2;
          description "1 day period";
        }
        enum "1-week" {
          value 3;
          description "1 week period";
        }
        enum "1-month" {
          value 4;
          description "1 month period";
        }
      }
    }

    typedef pm-validity {
      type enumeration {
        enum "false" {
          value 0;
          description "PM is not valid";
        }
        enum "true" {
          value 1;
          description "PM is valid";
        }
      }
    }

    typedef pm-index {
      type uint32;
      description "Index for PM history";
    }

    typedef pm-history {
      type enumeration {
        enum "current" {
          value 0;
          description
            "Current PM time-period";
        }
        enum "all" {
          value 1;
          description
            "All PM time-periods including current";
        }
      }
    }

    container pm-equipment {
      config false;
      description
        "Top container for all equipment performance monitoring entities.";
      list shelf {
        key "shelfId";
        description
          "List of shelf entities to store performance monitoring operational data";
        leaf shelfId {
          type string;
          description "Shelf Identifier";
        }

        list pm-oper-data {
          key "pm-name pm-location pm-direction";
          config false;
          ordered-by user;
          leaf pm-name {
            type pm-identity;
          }

          leaf pm-location {
            type pm-location;
          }

          leaf pm-direction {
            type pm-direction;
          }

          leaf pm-type {
            type pm-type;
          }

          list pm-time-period-index {
            key "pm-time-period pm-index";
            ordered-by user;
            leaf pm-time-period {
              type pm-time-period;
            }

            leaf pm-index {
              type pm-index;
            }

            leaf pm-value {
              type pm-data-type;
              description "PM value";
            }

            leaf pm-validity {
              type pm-validity;
            }

            leaf pm-start-time {
              type yang:date-and-time;
            }
          }  // list pm-time-period-index
        }  // list pm-oper-data

        list slot {
          key "slotId";
          description
            "List of slot entities to store performance monitoring operational data";
          leaf slotId {
            type string;
            description "Slot Identifier";
          }

          list pm-oper-data {
            key "pm-name pm-location pm-direction";
            config false;
            ordered-by user;
            leaf pm-name {
              type pm-identity;
            }

            leaf pm-location {
              type pm-location;
            }

            leaf pm-direction {
              type pm-direction;
            }

            leaf pm-type {
              type pm-type;
            }

            list pm-time-period-index {
              key "pm-time-period pm-index";
              ordered-by user;
              leaf pm-time-period {
                type pm-time-period;
              }

              leaf pm-index {
                type pm-index;
              }

              leaf pm-value {
                type pm-data-type;
                description "PM value";
              }

              leaf pm-validity {
                type pm-validity;
              }

              leaf pm-start-time {
                type yang:date-and-time;
              }
            }  // list pm-time-period-index
          }  // list pm-oper-data

          list subslot {
            key "subslotId";
            description
              "List of subslot entities to store performance monitoring operational data";
            leaf subslotId {
              type string;
              description
                "Subslot Identifier";
            }

            list pm-oper-data {
              key "pm-name pm-location pm-direction";
              config false;
              ordered-by user;
              leaf pm-name {
                type pm-identity;
              }

              leaf pm-location {
                type pm-location;
              }

              leaf pm-direction {
                type pm-direction;
              }

              leaf pm-type {
                type pm-type;
              }

              list pm-time-period-index {
                key "pm-time-period pm-index";
                ordered-by user;
                leaf pm-time-period {
                  type pm-time-period;
                }

                leaf pm-index {
                  type pm-index;
                }

                leaf pm-value {
                  type pm-data-type;
                  description "PM value";
                }

                leaf pm-validity {
                  type pm-validity;
                }

                leaf pm-start-time {
                  type yang:date-and-time;
                }
              }  // list pm-time-period-index
            }  // list pm-oper-data

            list port {
              key "portId";
              description
                "List of port entities to store performance monitoring operational data";
              leaf portId {
                type string;
                description
                  "Port Identifier";
              }

              list pm-oper-data {
                key "pm-name pm-location pm-direction";
                config false;
                ordered-by user;
                leaf pm-name {
                  type pm-identity;
                }

                leaf pm-location {
                  type pm-location;
                }

                leaf pm-direction {
                  type pm-direction;
                }

                leaf pm-type {
                  type pm-type;
                }

                list pm-time-period-index {
                  key "pm-time-period pm-index";
                  ordered-by user;
                  leaf pm-time-period {
                    type pm-time-period;
                  }

                  leaf pm-index {
                    type pm-index;
                  }

                  leaf pm-value {
                    type pm-data-type;
                    description "PM value";
                  }

                  leaf pm-validity {
                    type pm-validity;
                  }

                  leaf pm-start-time {
                    type yang:date-and-time;
                  }
                }  // list pm-time-period-index
              }  // list pm-oper-data

              list subport {
                key "subportId";
                description
                  "List of subport entities to store performance monitoring operational data";
                leaf subportId {
                  type string;
                  description
                    "Subport Identifier";
                }

                list pm-oper-data {
                  key "pm-name pm-location pm-direction";
                  config false;
                  ordered-by user;
                  leaf pm-name {
                    type pm-identity;
                  }

                  leaf pm-location {
                    type pm-location;
                  }

                  leaf pm-direction {
                    type pm-direction;
                  }

                  leaf pm-type {
                    type pm-type;
                  }

                  list pm-time-period-index {
                    key "pm-time-period pm-index";
                    ordered-by user;
                    leaf pm-time-period {
                      type pm-time-period;
                    }

                    leaf pm-index {
                      type pm-index;
                    }

                    leaf pm-value {
                      type pm-data-type;
                      description "PM value";
                    }

                    leaf pm-validity {
                      type pm-validity;
                    }

                    leaf pm-start-time {
                      type yang:date-and-time;
                    }
                  }  // list pm-time-period-index
                }  // list pm-oper-data
              }  // list subport
            }  // list port
          }  // list subslot
        }  // list slot
      }  // list shelf
    }  // container pm-equipment

    container pm-interfaces {
      config false;
      description
        "Top container for all interface performance monitoring entities.";
      list interface {
        key "name";
        description
          "List of interface entities to store performance monitoring operational data";
        leaf name {
          type string;
          description "Interface name";
        }

        list pm-oper-data {
          key "pm-name pm-location pm-direction";
          config false;
          ordered-by user;
          leaf pm-name {
            type pm-identity;
          }

          leaf pm-location {
            type pm-location;
          }

          leaf pm-direction {
            type pm-direction;
          }

          leaf pm-type {
            type pm-type;
          }

          list pm-time-period-index {
            key "pm-time-period pm-index";
            ordered-by user;
            leaf pm-time-period {
              type pm-time-period;
            }

            leaf pm-index {
              type pm-index;
            }

            leaf pm-value {
              type pm-data-type;
              description "PM value";
            }

            leaf pm-validity {
              type pm-validity;
            }

            leaf pm-start-time {
              type yang:date-and-time;
            }
          }  // list pm-time-period-index
        }  // list pm-oper-data
      }  // list interface
    }  // container pm-interfaces

    rpc init-pm {
      description
        "Command to initialize PM data";
      input {
        leaf id {
          type string;
          mandatory true;
          description "Entity Identifier";
        }

        leaf time-period {
          type pm-time-period;
          default "15-min";
        }

        leaf index {
          type pm-history;
          default "current";
        }
      }

      output {
        leaf status {
          type string;
        }
      }
    }  // rpc init-pm

    notification threshold-crossover-notification {
      description
        "This notification is used to report a threshold cross-over event.";
      leaf resource {
        type resource;
        mandatory true;
        description
          "The resource reporting the event.";
      }

      leaf event-type-id {
        type event-type-id;
        mandatory true;
        description
          "This leaf and the leaf 'event-type-qualifier' together
provides a unique identification of the event type.";
      }

      leaf event-type-qualifier {
        type event-type-qualifier;
        description
          "This leaf is used when the 'event-type-id' leaf cannot
uniquely identify the event type.
Event's location and direction are included in this qualifier.
Threshold crossover events would also include time-period";
      }

      leaf event-time {
        type yang:date-and-time;
        mandatory true;
        description
          "The time the event occurred.  The value represents the time
the real event occurred in the resource and not when it was
notified.";
      }

      leaf event-text {
        type event-text;
        mandatory true;
        description
          "A user friendly text describing the reason for event.";
      }

      leaf pm-value {
        type pm-data-type;
        mandatory true;
        description
          "Monitored performance value";
      }

      leaf pm-threshold-level {
        type pm-data-type;
        mandatory true;
        description
          "Performance monitor threshold level";
      }
    }  // notification threshold-crossover-notification
  }  // module fujitsu-performance-monitoring