submodule Cisco-IOS-XR-ncs4k-freqsync-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-ncs4k-freqsync-oper {
        prefix
          Cisco-IOS-XR-ncs4k-freqsync-oper;
    }

    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR ncs4k-freqsync package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-01-13" {
      description "Added ePRC QL code.";
    }

    revision "2019-12-18" {
      description
        "Added selection point input information, source information, SSM and satellite counters to line interfaces, and information about selection points.";
    }

    revision "2019-04-05" {
      description
        "Establish semantic version baseline.";
    }

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.2.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    typedef Fsync-bag-forwardtrace-node {
      type enumeration {
        enum
          "forward-trace-node-selection-point" {
          value 0;
          description
            "A selection point forwardtrace node";
        }
        enum "forward-trace-node-source" {
          value 1;
          description
            "A timing source forwardtrace node";
        }
      }
      description
        "Selection forwardtrace node information";
    }

    typedef Fsync-bag-clock-intf-class {
      type enumeration {
        enum "clock-class-bitst1" {
          value 0;
          description "BITS T1";
        }
        enum "clock-class-bitse1" {
          value 1;
          description "BITS E1";
        }
        enum "clock-class-bits2m" {
          value 2;
          description "BITS 2M";
        }
        enum "clock-class-bits6m" {
          value 3;
          description "BITS 6M";
        }
        enum "clock-class-bits64k" {
          value 4;
          description "BITS 64K";
        }
        enum "clock-class-dti" {
          value 5;
          description "DTI";
        }
        enum "clock-class-gps" {
          value 6;
          description "GPS";
        }
        enum "clock-class-chassis-sync" {
          value 7;
          description "Inter-Chassis Sync";
        }
        enum "clock-class-bitsj1" {
          value 8;
          description "Bits J1";
        }
        enum "clock-class-unknown" {
          value 255;
          description "Unknown";
        }
      }
      description "Clock-interface class";
    }

    typedef Fsync-bag-esmc-peer-state {
      type enumeration {
        enum "peer-down" {
          value 1808240398;
          description "Peer state down";
        }
        enum "peer-up" {
          value 1808240399;
          description "Peer state up";
        }
        enum "peer-timed-out" {
          value 1808240400;
          description "Peer state timed out";
        }
        enum "peer-unknown" {
          value 1808240401;
          description "Peer state unknown";
        }
      }
      description "ESMC peer state";
    }

    typedef Fsync-clock-id {
      type uint64;
      description "Fsync clock id";
    }

    typedef Fsync-bag-damping-state {
      type enumeration {
        enum "damping-state-down" {
          value 0;
          description "Down";
        }
        enum "damping-state-coming-up" {
          value 1;
          description "Coming up";
        }
        enum "damping-state-up" {
          value 2;
          description "Up";
        }
        enum "damping-state-going-down" {
          value 3;
          description "Going down";
        }
      }
      description "Damping state";
    }

    typedef Im-state-enum {
      type enumeration {
        enum "im-state-not-ready" {
          value 0;
          description "im state not ready";
        }
        enum "im-state-admin-down" {
          value 1;
          description "im state admin down";
        }
        enum "im-state-down" {
          value 2;
          description "im state down";
        }
        enum "im-state-up" {
          value 3;
          description "im state up";
        }
        enum "im-state-shutdown" {
          value 4;
          description "im state shutdown";
        }
        enum "im-state-err-disable" {
          value 5;
          description "im state err disable";
        }
        enum "im-state-down-immediate" {
          value 6;
          description
            "im state down immediate";
        }
        enum "im-state-down-immediate-admin" {
          value 7;
          description
            "im state down immediate admin";
        }
        enum "im-state-down-graceful" {
          value 8;
          description
            "im state down graceful";
        }
        enum "im-state-begin-shutdown" {
          value 9;
          description
            "im state begin shutdown";
        }
        enum "im-state-end-shutdown" {
          value 10;
          description
            "im state end shutdown";
        }
        enum "im-state-begin-error-disable" {
          value 11;
          description
            "im state begin error disable";
        }
        enum "im-state-end-error-disable" {
          value 12;
          description
            "im state end error disable";
        }
        enum "im-state-begin-down-graceful" {
          value 13;
          description
            "im state begin down graceful";
        }
        enum "im-state-reset" {
          value 14;
          description "im state reset";
        }
        enum "im-state-operational" {
          value 15;
          description "im state operational";
        }
        enum "im-state-not-operational" {
          value 16;
          description
            "im state not operational";
        }
        enum "im-state-unknown" {
          value 17;
          description "im state unknown";
        }
        enum "im-state-last" {
          value 18;
          description "im state last";
        }
      }
      description "Im state enum";
    }

    typedef Fsync-bag-optional-string {
      type string;
      description
        "Fsync bag optional string";
    }

    typedef Fsync-bag-stream-state {
      type enumeration {
        enum "stream-invalid" {
          value 0;
          description "Invalid stream";
        }
        enum "stream-unqualified" {
          value 1;
          description "Unqualified stream";
        }
        enum "stream-available" {
          value 2;
          description "Stream available";
        }
        enum "stream-acquiring" {
          value 3;
          description "Stream acquiring";
        }
        enum "stream-locked" {
          value 4;
          description "Stream locked";
        }
        enum "stream-holdover" {
          value 5;
          description "Stream in holdover";
        }
        enum "stream-freerun" {
          value 6;
          description "Stream free running";
        }
        enum "stream-failed" {
          value 7;
          description "Stream failed";
        }
        enum "stream-unmonitored" {
          value 8;
          description "Unmonitored stream";
        }
        enum "stream-error" {
          value 9;
          description "Stream error";
        }
      }
      description "Platform stream status";
    }

    typedef Fsync-output-id {
      type uint8;
      description "Fsync output id";
    }

    typedef Fsync-bag-source-class {
      type enumeration {
        enum "invalid-source" {
          value 0;
          description "Invalid source class";
        }
        enum "ethernet-interface-source" {
          value 1;
          description "Ethernet interface";
        }
        enum "sonet-interface-source" {
          value 2;
          description "SONET interface";
        }
        enum "clock-interface-source" {
          value 3;
          description "Clock interface";
        }
        enum "internal-clock-source" {
          value 4;
          description "Internal clock";
        }
        enum "ptp-source" {
          value 5;
          description "PTP clock";
        }
        enum
          "satellite-access-interface-source" {
          value 6;
          description
            "Satellite Access Interface";
        }
        enum "ntp-source" {
          value 7;
          description "NTP clock";
        }
        enum "gnss-receiver" {
          value 8;
          description "GNSS Receiver";
        }
      }
      description "Source class";
    }

    typedef Fsync-bag-stream-input {
      type enumeration {
        enum "invalid-input" {
          value 0;
          description "Invalid stream input";
        }
        enum "source-input" {
          value 1;
          description "Source stream input";
        }
        enum "selection-point-input" {
          value 2;
          description
            "Selection point stream input";
        }
      }
      description "Stream input type";
    }

    typedef Fsync-bag-selection-point-desc {
      type string;
      description
        "Fsync bag selection point desc";
    }

    typedef Fsync-selection-point-type {
      type uint8;
      description
        "Fsync selection point type";
    }

    typedef Fsync-bag-ql-o2-g2-value {
      type enumeration {
        enum "option2-generation2-invalid" {
          value 0;
          description "Invalid";
        }
        enum
          "option2-generation2-do-not-use" {
          value 1;
          description "Do not use";
        }
        enum "option2-generation2-failed" {
          value 2;
          description "Failed";
        }
        enum "option2-generation2-none" {
          value 3;
          description
            "Interface does not support SSMs or no QL has
           been received";
        }
        enum "option2e-prtc" {
          value 60;
          description
            "Enhanced primary reference timing clock";
        }
        enum "option2prtc" {
          value 61;
          description
            "Primary reference timing clock";
        }
        enum "option2-generation2prs" {
          value 62;
          description
            "Primary reference source";
        }
        enum "option2-generation2stu" {
          value 63;
          description
            "Synchronized - traceability unknown";
        }
        enum "option2-generation2-stratum2" {
          value 64;
          description "Stratum 2";
        }
        enum "option2-generation2tnc" {
          value 65;
          description "Transit node clock";
        }
        enum "option2-generation2-stratum3e" {
          value 66;
          description "Stratum 3E";
        }
        enum "option2-generation2-stratum3" {
          value 67;
          description "Stratum 3";
        }
        enum "option2e-eec" {
          value 68;
          description
            "Enhanced ethernet equipment clock";
        }
        enum "option2eec2" {
          value 69;
          description
            "Ethernet equipment clock";
        }
        enum "option2-generation2smc" {
          value 70;
          description
            "SONET clock self timed";
        }
        enum "option2-generation2-stratum4" {
          value 71;
          description "Stratum 4 freerun";
        }
        enum "option2e-prc" {
          value 73;
          description
            "Enhanced primary reference clock";
        }
      }
      description
        "Quality level option 2, generation 2 values";
    }

    typedef Fsync-bag-ql-o2-g1-value {
      type enumeration {
        enum "option2-generation1-invalid" {
          value 0;
          description "Invalid";
        }
        enum
          "option2-generation1-do-not-use" {
          value 1;
          description "Do not use";
        }
        enum "option2-generation1-failed" {
          value 2;
          description "Failed";
        }
        enum "option2-generation1-none" {
          value 3;
          description
            "Interface does not support SSMs or no QL has
           been received";
        }
        enum "option2e-prtc" {
          value 40;
          description
            "Enhanced primary reference timing clock";
        }
        enum "option2prtc" {
          value 41;
          description
            "Primary reference timing clock";
        }
        enum "option2-generation1prs" {
          value 42;
          description
            "Primary reference source";
        }
        enum "option2-generation1stu" {
          value 43;
          description
            "Synchronized - traceability unknown";
        }
        enum "option2-generation1-stratum2" {
          value 44;
          description "Stratum 2";
        }
        enum "option2-generation1-stratum3" {
          value 45;
          description "Stratum 3";
        }
        enum "option2e-eec" {
          value 46;
          description
            "Enhanced ethernet equipment clock";
        }
        enum "option2eec2" {
          value 47;
          description
            "Ethernet equipment clock";
        }
        enum "option2-generation1smc" {
          value 48;
          description
            "SONET clock self timed";
        }
        enum "option2-generation1-stratum4" {
          value 49;
          description "Stratum 4 freerun";
        }
        enum "option2e-prc" {
          value 51;
          description
            "Enhanced primary reference clock";
        }
      }
      description
        "Quality level option 2, generation 1 values";
    }

    typedef Fsync-bag-ql-o1-value {
      type enumeration {
        enum "option1-invalid" {
          value 0;
          description "Invalid";
        }
        enum "option1-do-not-use" {
          value 1;
          description "Do not use";
        }
        enum "option1-failed" {
          value 2;
          description "Failed";
        }
        enum "option1-none" {
          value 3;
          description
            "Interface does not support SSMs or no QL has
           been received";
        }
        enum "option1e-prtc" {
          value 20;
          description
            "Enhanced primary reference timing clock";
        }
        enum "option1prtc" {
          value 21;
          description
            "Primary reference timing clock";
        }
        enum "option1prc" {
          value 22;
          description
            "Primary reference clock";
        }
        enum "option1ssu-a" {
          value 23;
          description
            "Type I or V slave clock";
        }
        enum "option1ssu-b" {
          value 24;
          description "Type VI slave clock";
        }
        enum "option1e-eec" {
          value 25;
          description
            "Enhanced ethernet equipment clock";
        }
        enum "option1eec1" {
          value 26;
          description
            "Ethernet equipment clock";
        }
        enum "option1sec" {
          value 27;
          description
            "SONET equipment clock";
        }
        enum "option1e-prc" {
          value 28;
          description
            "Enhanced primary reference clock";
        }
      }
      description
        "Quality level option 1 values";
    }

    typedef Fsync-bag-ql-option {
      type enumeration {
        enum "no-quality-level-option" {
          value 0;
          description
            "Interface does not support SSMs or no QL has
           been received";
        }
        enum "option1" {
          value 1;
          description
            "ITU-T Quality level option 1";
        }
        enum "option2-generation1" {
          value 2;
          description
            "ITU-T Quality level option 2, generation 1";
        }
        enum "option2-generation2" {
          value 3;
          description
            "ITU-T Quality level option 2, generation 2";
        }
        enum "invalid-quality-level-option" {
          value 4;
          description
            "Invalid quality level option";
        }
      }
      description "Quality level option";
    }

    typedef Fsync-time-pri {
      type uint8;
      description "Fsync time pri";
    }

    typedef Fsync-pri {
      type uint8;
      description "Fsync pri";
    }

    typedef Fsync-bag-source-state {
      type enumeration {
        enum "source-state-unknown" {
          value 0;
          description "Unknown";
        }
        enum "source-state-up" {
          value 1;
          description "Up";
        }
        enum "source-state-down" {
          value 2;
          description "Down";
        }
        enum "source-state-unavailable" {
          value 3;
          description "Unvailable";
        }
      }
      description "Source state";
    }

    grouping FSYNC-BAG-FORWARDTRACE-NODE {
      description
        "Selection forwardtrace node";
      container selection-point {
        when
          "../node-type = 'forward-trace-node-selection-point'" {
          description
            "../NodeType = 'ForwardTraceNodeSelectionPoint'";
        }
        description "Selection Point";
        uses FSYNC-BAG-SP-ID;
      }  // container selection-point

      container source {
        when
          "../node-type = 'forward-trace-node-source'" {
          description
            "../NodeType = 'ForwardTraceNodeSource'";
        }
        description "Timing Source";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container source

      leaf node-type {
        type Fsync-bag-forwardtrace-node;
        description "NodeType";
      }
    }  // grouping FSYNC-BAG-FORWARDTRACE-NODE

    grouping FSYNC-BAG-FORWARDTRACE {
      description "Selection forwardtrace";
      container forward-trace-node {
        description
          "The source or selection point at this point in
         the forwardtrace";
        uses FSYNC-BAG-FORWARDTRACE-NODE;
      }  // container forward-trace-node
    }  // grouping FSYNC-BAG-FORWARDTRACE

    grouping FSYNC-SELECTION-FORWARDTRACE-INFO {
      description
        "Selection forwardtrace information";
      list forward-trace {
        description "Selection ForwardTrace";
        uses FSYNC-BAG-FORWARDTRACE;
      }  // list forward-trace
    }  // grouping FSYNC-SELECTION-FORWARDTRACE-INFO

    grouping FSYNC-SELECTION-BACKTRACE-INFO {
      description
        "Selection backtrace information";
      container selected-source {
        description
          "Source which has been selected for output";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container selected-source

      list selection-point {
        description
          "List of selection points in the backtrace";
        uses FSYNC-BAG-SP-ID;
      }  // list selection-point
    }  // grouping FSYNC-SELECTION-BACKTRACE-INFO

    grouping FSYNC-BAG-SUMMARY-TOD-INFO {
      description
        "Time-of-day summary information";
      container source {
        description
          "The source associated with this summary
         information";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container source

      leaf node-count {
        type uint32;
        description
          "The number of cards having their time-of-day set
         by the source";
      }
    }  // grouping FSYNC-BAG-SUMMARY-TOD-INFO

    grouping FSYNC-BAG-SUMMARY-FREQ-INFO {
      description
        "Frequency summary information";
      container source {
        description
          "The source associated with this summary
         information";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container source

      leaf clock-count {
        type uint32;
        description
          "The number of clock-interfaces being driven by
         the source";
      }

      leaf ethernet-count {
        type uint32;
        description
          "The number of Ethernet interfaces being driven
         by the source";
      }

      leaf sonet-count {
        type uint32;
        description
          "The number of SONET/SDH interfaces being driven
         by the source";
      }
    }  // grouping FSYNC-BAG-SUMMARY-FREQ-INFO

    grouping FSYNC-SUMMARY-INFO {
      description
        "Frequency Synchronization summary information";
      list frequency-summary {
        description
          "Summary of sources selected for frequency";
        uses FSYNC-BAG-SUMMARY-FREQ-INFO;
      }  // list frequency-summary

      list time-of-day-summary {
        description
          "Summary of sources selected for time-of-day";
        uses FSYNC-BAG-SUMMARY-TOD-INFO;
      }  // list time-of-day-summary
    }  // grouping FSYNC-SUMMARY-INFO

    grouping FSYNC-CLOCK-INFO-V2 {
      description
        "Clock interface information";
      container source {
        description
          "The source ID for the clock";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container source

      container selected-source {
        description
          "Timing source selected for clock output";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container selected-source

      container quality-level-received {
        description "Received quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-received

      container quality-level-damped {
        description
          "Quality level after damping has been applied";
        uses FSYNC-BAG-QL;
      }  // container quality-level-damped

      container quality-level-effective-input {
        description
          "The effective input quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-effective-input

      container quality-level-effective-output {
        description
          "The effective output quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-effective-output

      container quality-level-selected-source {
        description
          "The quality level of the source driving this
         interface";
        uses FSYNC-BAG-QL;
      }  // container quality-level-selected-source

      leaf state {
        type Fsync-bag-source-state;
        description "Clock state";
      }

      leaf down-reason {
        type Fsync-bag-optional-string;
        description "Why the clock is down";
      }

      leaf description {
        type string;
        description "Clock description";
      }

      leaf priority {
        type Fsync-pri;
        description "Priority";
      }

      leaf time-of-day-priority {
        type Fsync-time-pri;
        description "Time-of-day priority";
      }

      leaf ssm-support {
        type boolean;
        description
          "The clock supports SSMs";
      }

      leaf ssm-enabled {
        type boolean;
        description
          "The clock output is squelched";
      }

      leaf loopback {
        type boolean;
        description
          "The clock is looped back";
      }

      leaf selection-input {
        type boolean;
        description
          "The clock is an input for selection";
      }

      leaf squelched {
        type boolean;
        description
          "The clock output is squelched";
      }

      leaf damping-state {
        type Fsync-bag-damping-state;
        description "Damping state";
      }

      leaf damping-time {
        type uint32;
        description
          "Time until damping state changes in ms";
      }

      leaf input-disabled {
        type boolean;
        description
          "Timing input is disabled";
      }

      leaf output-disabled {
        type boolean;
        description
          "Timing output is disabled";
      }

      leaf wait-to-restore-time {
        type uint16;
        description
          "Wait-to-restore time for the clock";
      }

      leaf clock-type {
        type Fsync-bag-clock-intf-class;
        description "The type of clock";
      }

      leaf supports-frequency {
        type boolean;
        description
          "The PTP clock supports frequency";
      }

      leaf supports-time-of-day {
        type boolean;
        description
          "The PTP clock supports time";
      }

      list spa-selection-point {
        description "Spa selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list spa-selection-point

      list node-selection-point {
        description "Node selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list node-selection-point
    }  // grouping FSYNC-CLOCK-INFO-V2

    grouping FSYNC-BAG-ETH-PEER-INFO {
      description
        "Ethernet peer information";
      container peer-state-time {
        description
          "Time of last peer state transition";
        uses FSYNC-BAG-TIMESTAMP;
      }  // container peer-state-time

      container last-ssm {
        description
          "Time of last SSM received";
        uses FSYNC-BAG-TIMESTAMP;
      }  // container last-ssm

      leaf peer-state {
        type Fsync-bag-esmc-peer-state;
        description "Peer state";
      }

      leaf peer-up-count {
        type uint16;
        description
          "Number of times the peer has come up";
      }

      leaf peer-timeout-count {
        type uint16;
        description
          "Number of times the peer has timed out";
      }
    }  // grouping FSYNC-BAG-ETH-PEER-INFO

    grouping FSYNC-BAG-QL-DATA {
      description "Quality level data";
      leaf originator-clock-id {
        type Fsync-clock-id;
        description "Originator clock ID";
      }

      leaf sync-e-steps {
        type uint8;
        description "SyncE steps";
      }

      leaf esync-e-steps {
        type uint8;
        description "Enhanced SyncE steps";
      }

      leaf all-steps-e-sync-e {
        type boolean;
        description
          "Whether all steps are running enhanced SyncE";
      }

      leaf chain-complete {
        type boolean;
        description
          "Whether the chain of extended QL TLVs is
         complete";
      }
    }  // grouping FSYNC-BAG-QL-DATA

    grouping FSYNC-BAG-SAT-INFO-TYPE {
      description "Satellite info type";
      leaf satellite-id {
        type uint16;
        description "The satellite ID";
      }

      leaf sdac-key-length {
        type uint16;
        description
          "The length of the SDAC key";
      }

      leaf-list sdac-key {
        type uint8;
        description "The SDAC key";
      }
    }  // grouping FSYNC-BAG-SAT-INFO-TYPE

    grouping FSYNC-BAG-ETH-ESMC-STATS {
      description "ESMC Statistics";
      leaf esmc-events-sent {
        type uint16;
        description
          "Number of event SSMs sent";
      }

      leaf esmc-events-received {
        type uint16;
        description
          "Number of event SSMs received";
      }

      leaf esmc-infos-sent {
        type uint32;
        description
          "Number of info SSMs sent";
      }

      leaf esmc-infos-received {
        type uint32;
        description
          "Number of info SSms received";
      }

      leaf esmc-dn-us-sent {
        type uint32;
        description
          "Number of SSMs with DNU QL sent";
      }

      leaf esmc-dn-us-received {
        type uint32;
        description
          "Number of SSMs with DNU QL received";
      }

      leaf esmc-malformed-received {
        type uint16;
        description
          "Number of malformed packets received";
      }

      leaf esmc-received-error {
        type uint16;
        description
          "Number of received packets that failed to be
         handled";
      }
    }  // grouping FSYNC-BAG-ETH-ESMC-STATS

    grouping FSYNC-IF-INFO-V2 {
      description
        "Line interface information";
      container source {
        description
          "The source ID for the interface";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container source

      container selected-source {
        description
          "Timing source selected for interface output";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container selected-source

      container ssm-counters {
        description
          "Counters for sent and received SSMs on ESMC
         enabled interfaces";
        uses FSYNC-BAG-ETH-ESMC-STATS;
      }  // container ssm-counters

      container sat-info {
        description
          "Sat info for the source if source is a sat
         access interface";
        uses FSYNC-BAG-SAT-INFO-TYPE;
      }  // container sat-info

      container quality-level-received {
        description "Received quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-received

      container quality-level-damped {
        description
          "Quality level after damping has been applied";
        uses FSYNC-BAG-QL;
      }  // container quality-level-damped

      container quality-level-effective-input {
        description
          "The effective input quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-effective-input

      container quality-level-effective-output {
        description
          "The effective output quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-effective-output

      container quality-level-selected-source {
        description
          "The quality level of the source driving this
         interface";
        uses FSYNC-BAG-QL;
      }  // container quality-level-selected-source

      container ql-data-received {
        description
          "Received quality level data";
        uses FSYNC-BAG-QL-DATA;
      }  // container ql-data-received

      container ql-data-to-send {
        description
          "Quality level data to be sent";
        uses FSYNC-BAG-QL-DATA;
      }  // container ql-data-to-send

      container ethernet-peer-information {
        description
          "Ethernet peer information";
        uses FSYNC-BAG-ETH-PEER-INFO;
      }  // container ethernet-peer-information

      container esmc-statistics {
        description "ESMC Statistics";
        uses FSYNC-BAG-ETH-ESMC-STATS;
      }  // container esmc-statistics

      leaf name {
        type string;
        description "Interface name";
      }

      leaf state {
        type Im-state-enum;
        description "Interface state";
      }

      leaf ssm-enabled {
        type boolean;
        description
          "SSM is enabled on the interface";
      }

      leaf squelched {
        type boolean;
        description
          "The interface output is squelched";
      }

      leaf selection-input {
        type boolean;
        description
          "The interface is an input for selection";
      }

      leaf priority {
        type Fsync-pri;
        description "Priority";
      }

      leaf time-of-day-priority {
        type Fsync-time-pri;
        description "Time-of-day priority";
      }

      leaf damping-state {
        type Fsync-bag-damping-state;
        description "Damping state";
      }

      leaf damping-time {
        type uint32;
        description
          "Time until damping state changes in ms";
      }

      leaf wait-to-restore-time {
        type uint16;
        description
          "Wait-to-restore time for the interface";
      }

      leaf supports-frequency {
        type boolean;
        description
          "The PTP clock supports frequency";
      }

      leaf supports-time-of-day {
        type boolean;
        description
          "The PTP clock supports time";
      }

      leaf source-flags {
        type uint32;
        description "The source flags";
      }

      leaf mac-address {
        type string {
          length "0..6";
        }
        description
          "The MAC address of the source";
      }

      leaf source-config-flags {
        type uint8;
        description
          "The source configuration flags";
      }

      leaf last-up-down {
        type uint32;
        description
          "Time the interface last went up or down";
      }

      leaf platform-state {
        type Fsync-bag-source-state;
        description
          "Platform state for the source";
      }

      leaf pd-down-reason {
        type Fsync-bag-optional-string;
        description "Why the stream is down";
      }

      list local-stream {
        description "The local streams";
        uses FSYNC-BAG-STREAM-ID;
      }  // list local-stream

      list spa-selection-point {
        description "Spa selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list spa-selection-point

      list node-selection-point {
        description "Node selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list node-selection-point
    }  // grouping FSYNC-IF-INFO-V2

    grouping FSYNC-SSM-INFO {
      description "SSM summary information";
      leaf ethernet-sources {
        type uint32;
        description
          "Number of ethernet interfaces in synchronous
         mode";
      }

      leaf ethernet-sources-select {
        type uint32;
        description
          "Number of ethernet interfaces assigned for
         selection";
      }

      leaf ethernet-sources-enabled {
        type uint32;
        description
          "Number of ethernet interfaces with SSM enabled";
      }

      leaf sonet-sources {
        type uint32;
        description
          "Number of SONET interfaces in synchronous mode";
      }

      leaf sonet-sources-select {
        type uint32;
        description
          "Number of SONET interfaces assigned for
         selection";
      }

      leaf sonet-sources-enabled {
        type uint32;
        description
          "Number of SONET interfaces with SSM enabled";
      }

      leaf events-sent {
        type uint32;
        description "Total event SSMs sent";
      }

      leaf events-received {
        type uint32;
        description
          "Total event SSMs received";
      }

      leaf infos-sent {
        type uint32;
        description
          "Total information SSMs sent";
      }

      leaf infos-received {
        type uint32;
        description
          "Total information SSMs received";
      }

      leaf dn-us-sent {
        type uint32;
        description "Total DNU SSMs sent";
      }

      leaf dn-us-received {
        type uint32;
        description
          "Total DNU SSMs received";
      }
    }  // grouping FSYNC-SSM-INFO

    grouping FSYNC-BAG-TIMESTAMP {
      description "Timestamp";
      leaf seconds {
        type uint32;
        units "second";
        description "Seconds";
      }

      leaf nanoseconds {
        type uint32;
        units "nanosecond";
        description "Nanoseconds";
      }
    }  // grouping FSYNC-BAG-TIMESTAMP

    grouping FSYNC-BAG-SP-OUTPUT-DEF-V2 {
      description
        "Output information for a selection point or
       interface";
      leaf local-clock-ouput {
        type boolean;
        description
          "Used for local clock output";
      }

      leaf local-line-output {
        type boolean;
        description
          "Used for local line interface output";
      }

      leaf local-time-of-day-output {
        type boolean;
        description
          "Used for local time-of-day output";
      }

      list spa-selection-point {
        description "SPA selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list spa-selection-point

      list node-selection-point {
        description "Node selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list node-selection-point

      list chassis-selection-point {
        description
          "Chassis selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list chassis-selection-point

      list router-selection-point {
        description
          "Router selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list router-selection-point
    }  // grouping FSYNC-BAG-SP-OUTPUT-DEF-V2

    grouping FSYNC-SP-INFO-V2 {
      description
        "Selection point information";
      container output {
        description
          "Information about the output of the selection
         point";
        uses FSYNC-BAG-SP-OUTPUT-DEF-V2;
      }  // container output

      container last-programmed {
        description
          "Time the SP was last programmed";
        uses FSYNC-BAG-TIMESTAMP;
      }  // container last-programmed

      container last-selection {
        description
          "Time the last selection was made";
        uses FSYNC-BAG-TIMESTAMP;
      }  // container last-selection

      leaf selection-point-type {
        type Fsync-selection-point-type;
        description "Selection Point Type";
      }

      leaf description {
        type string;
        description "Description";
      }

      leaf inputs {
        type uint32;
        description "Number of inputs";
      }

      leaf inputs-selected {
        type uint32;
        description
          "Number of inputs that are selected";
      }

      leaf time-of-day-selection {
        type boolean;
        description
          "The selection point is a time-of-day selection
         point";
      }

      leaf pending-s-ps {
        type uint32;
        description
          "Flags indicating which SPs must be programmed
         before this SP";
      }

      leaf sp-flags {
        type uint8;
        description
          "Flags for the SP structure";
      }

      list stream {
        description
          "A list of stream IDs which are valid inputs to
         this SP";
        uses FSYNC-BAG-STREAM-ID;
      }  // list stream
    }  // grouping FSYNC-SP-INFO-V2

    grouping FSYNC-BAG-ERROR {
      description
        "Source QL config error information";
      container source {
        description "Source";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container source

      container input-min-ql {
        description
          "Configured minimum input QL";
        uses FSYNC-BAG-QL;
      }  // container input-min-ql

      container input-exact-ql {
        description
          "Configured exact input QL";
        uses FSYNC-BAG-QL;
      }  // container input-exact-ql

      container input-max-ql {
        description
          "Configured maximum input QL";
        uses FSYNC-BAG-QL;
      }  // container input-max-ql

      container output-min-ql {
        description
          "Configured mininum output QL";
        uses FSYNC-BAG-QL;
      }  // container output-min-ql

      container output-exact-ql {
        description
          "Configured exact output QL";
        uses FSYNC-BAG-QL;
      }  // container output-exact-ql

      container output-max-ql {
        description
          "Configured exact maximum QL";
        uses FSYNC-BAG-QL;
      }  // container output-max-ql

      leaf enable-error {
        type boolean;
        description
          "Frequency Synchronization enable error";
      }

      leaf input-min-error {
        type boolean;
        description
          "Minimum input QL option config error";
      }

      leaf input-exact-error {
        type boolean;
        description
          "Exact input QL config error";
      }

      leaf input-max-error {
        type boolean;
        description
          "Maximum input QL option config error";
      }

      leaf ouput-min-error {
        type boolean;
        description
          "Minimum output QL option config error";
      }

      leaf output-exact-error {
        type boolean;
        description
          "Exact output QL option config error";
      }

      leaf output-max-error {
        type boolean;
        description
          "Maximum output QL option config error";
      }

      leaf ext-ql-input-min-error {
        type boolean;
        description
          "Minimum input extended QL config error";
      }

      leaf ext-ql-input-exact-error {
        type boolean;
        description
          "Exact input extended QL config error";
      }

      leaf ext-ql-input-max-error {
        type boolean;
        description
          "Maximum input extended Ql config error";
      }

      leaf ext-ql-ouput-min-error {
        type boolean;
        description
          "Minimum output extended QL config error";
      }

      leaf ext-ql-output-exact-error {
        type boolean;
        description
          "Exact output extended QL config error";
      }

      leaf ext-ql-output-max-error {
        type boolean;
        description
          "Maximum output extended QL config error";
      }

      leaf input-output-mismatch {
        type boolean;
        description
          "Input/Output mismatch error";
      }
    }  // grouping FSYNC-BAG-ERROR

    grouping FSYNC-CONFIG-ERRORS-INFO {
      description
        "Configuration error information";
      list error-source {
        description "Configuration errors";
        uses FSYNC-BAG-ERROR;
      }  // list error-source
    }  // grouping FSYNC-CONFIG-ERRORS-INFO

    grouping FSYNC-NTP-INFO-V2 {
      description
        "Frequency Synchronization NTP information";
      container quality-level-effective-input {
        description
          "The effective input quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-effective-input

      leaf state {
        type Fsync-bag-source-state;
        description "NTP state";
      }

      leaf supports-frequency {
        type boolean;
        description
          "The NTP clock supports frequency";
      }

      leaf supports-time-of-day {
        type boolean;
        description
          "The NTP clock supports time";
      }

      leaf frequency-priority {
        type Fsync-pri;
        description
          "The priority of the NTP clock when selected
         between frequency sources";
      }

      leaf time-of-day-priority {
        type Fsync-time-pri;
        description
          "The priority of the NTP clock when selecting
         between time-of-day sources";
      }

      list spa-selection-point {
        description "Spa selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list spa-selection-point

      list node-selection-point {
        description "Node selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list node-selection-point
    }  // grouping FSYNC-NTP-INFO-V2

    grouping FSYNC-BAG-LAST-SP-ID {
      description "Last selection point ID";
      container selection-point {
        description "Last selection point";
        uses FSYNC-BAG-SP-ID;
      }  // container selection-point

      leaf output-id {
        type Fsync-output-id;
        description "Output ID";
      }
    }  // grouping FSYNC-BAG-LAST-SP-ID

    grouping FSYNC-BAG-CLOCK-ID {
      description "Clock ID";
      leaf node {
        type xr:Node-id;
        description "Node";
      }

      leaf id {
        type uint32;
        description
          "ID (port number for clock interface, receiver
         number for GNSS receiver)";
      }

      leaf clock-name {
        type string {
          length "0..144";
        }
        description "Name";
      }
    }  // grouping FSYNC-BAG-CLOCK-ID

    grouping FSYNC-BAG-SOURCE-ID {
      description "Source ID";
      container clock-id {
        when
          "../source-class = 'clock-interface-source'" {
          description
            "../SourceClass = 'ClockInterfaceSource'";
        }
        description "Clock ID";
        uses FSYNC-BAG-CLOCK-ID;
      }  // container clock-id

      container internal-clock-id {
        when
          "../source-class = 'internal-clock-source'" {
          description
            "../SourceClass = 'InternalClockSource'";
        }
        description "Internal Clock ID";
        uses FSYNC-BAG-CLOCK-ID;
      }  // container internal-clock-id

      container gnss-receiver-id {
        when
          "../source-class = 'gnss-receiver'" {
          description
            "../SourceClass = 'GNSSReceiver'";
        }
        description "GNSS Receiver ID";
        uses FSYNC-BAG-CLOCK-ID;
      }  // container gnss-receiver-id

      leaf source-class {
        type Fsync-bag-source-class;
        description "SourceClass";
      }

      leaf ethernet-interface {
        when
          "../source-class = 'ethernet-interface-source'" {
          description
            "../SourceClass = 'EthernetInterfaceSource'";
        }
        type xr:Interface-name;
        description "Ethernet interface";
      }

      leaf sonet-interface {
        when
          "../source-class = 'sonet-interface-source'" {
          description
            "../SourceClass = 'SONETInterfaceSource'";
        }
        type xr:Interface-name;
        description "SONET interfaces";
      }

      leaf ptp-node {
        when
          "../source-class = 'ptp-source'" {
          description
            "../SourceClass = 'PTPSource'";
        }
        type xr:Node-id;
        description "PTP Clock Node";
      }

      leaf satellite-access-interface {
        when
          "../source-class = 'satellite-access-interface-source'" {
          description
            "../SourceClass =
           'SatelliteAccessInterfaceSource'";
        }
        type xr:Interface-name;
        description
          "Satellite Access Interface";
      }

      leaf ntp-node {
        when
          "../source-class = 'ntp-source'" {
          description
            "../SourceClass = 'NTPSource'";
        }
        type xr:Node-id;
        description "NTP Clock Node";
      }
    }  // grouping FSYNC-BAG-SOURCE-ID

    grouping FSYNC-BAG-STREAM-ID {
      description "Stream ID";
      container source-id {
        when
          "../stream-input = 'source-input'" {
          description
            "../StreamInput = 'SourceInput'";
        }
        description "Source ID";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container source-id

      container selection-point-id {
        when
          "../stream-input = 'selection-point-input'" {
          description
            "../StreamInput = 'SelectionPointInput'";
        }
        description "Selection point ID";
        uses FSYNC-BAG-LAST-SP-ID;
      }  // container selection-point-id

      leaf stream-input {
        type Fsync-bag-stream-input;
        description "StreamInput";
      }
    }  // grouping FSYNC-BAG-STREAM-ID

    grouping FSYNC-BAG-SP-ID {
      description "Selection point ID";
      leaf selection-point-type {
        type Fsync-selection-point-type;
        description "Selection point type";
      }

      leaf selection-point-description {
        type Fsync-bag-selection-point-desc;
        description
          "Selection point descrption";
      }

      leaf node {
        type xr:Node-id;
        description "Node";
      }
    }  // grouping FSYNC-BAG-SP-ID

    grouping FSYNC-SP-INPUT-INFO {
      description
        "Selection point input information";
      container input-selection-point {
        description
          "The selection point the input is for";
        uses FSYNC-BAG-SP-ID;
      }  // container input-selection-point

      container stream {
        description "Stream";
        uses FSYNC-BAG-STREAM-ID;
      }  // container stream

      container original-source {
        description "Original source";
        uses FSYNC-BAG-SOURCE-ID;
      }  // container original-source

      container quality-level {
        description "Quality Level";
        uses FSYNC-BAG-QL;
      }  // container quality-level

      leaf supports-frequency {
        type boolean;
        description
          "The selection point input supports frequency";
      }

      leaf supports-time-of-day {
        type boolean;
        description
          "The selection point input supports time-of-day";
      }

      leaf priority {
        type Fsync-pri;
        description "Priority";
      }

      leaf time-of-day-priority {
        type Fsync-time-pri;
        description "Time-of-day priority";
      }

      leaf selected {
        type boolean;
        description
          "The selection point input is selected";
      }

      leaf output-id-xr {
        type Fsync-output-id;
        description
          "Platform output ID, if the input is selected";
      }

      leaf platform-status {
        type Fsync-bag-stream-state;
        description "Platform status";
      }

      leaf platform-failed-reason {
        type Fsync-bag-optional-string;
        description
          "Why the stream has failed";
      }

      leaf source {
        type string {
          length "0..144";
        }
        description
          "Description of the source that this stream
         represents (if any)";
      }

      leaf stale {
        type boolean;
        description "The stream is stale";
      }

      leaf removed {
        type boolean;
        description
          "Stream has been removed as input to this SP but
         is still selected";
      }

      leaf pd-update {
        type boolean;
        description
          "Stream has update that has yet to be processed";
      }
    }  // grouping FSYNC-SP-INPUT-INFO

    grouping FSYNC-BAG-SP-INFO {
      description
        "Selection point information";
      leaf selection-point {
        type Fsync-selection-point-type;
        description "Selection point ID";
      }

      leaf selection-point-description {
        type Fsync-bag-selection-point-desc;
        description
          "Selection point description";
      }
    }  // grouping FSYNC-BAG-SP-INFO

    grouping FSYNC-BAG-QL {
      description "Quality level";
      leaf quality-level-option {
        type Fsync-bag-ql-option;
        description "QualityLevelOption";
      }

      leaf option1-value {
        when
          "../quality-level-option = 'option1'" {
          description
            "../QualityLevelOption = 'Option1'";
        }
        type Fsync-bag-ql-o1-value;
        description
          "ITU-T Option 1 QL value";
      }

      leaf option2-generation1-value {
        when
          "../quality-level-option = 'option2-generation1'" {
          description
            "../QualityLevelOption = 'Option2Generation1'";
        }
        type Fsync-bag-ql-o2-g1-value;
        description
          "ITU-T Option 2, generation 1 value";
      }

      leaf option2-generation2-value {
        when
          "../quality-level-option = 'option2-generation2'" {
          description
            "../QualityLevelOption = 'Option2Generation2'";
        }
        type Fsync-bag-ql-o2-g2-value;
        description
          "ITU-T Option 2, generation 2 value";
      }
    }  // grouping FSYNC-BAG-QL

    grouping FSYNC-PTP-INFO-V2 {
      description
        "Frequency Synchronization PTP information";
      container quality-level-effective-input {
        description
          "The effective input quality level";
        uses FSYNC-BAG-QL;
      }  // container quality-level-effective-input

      leaf state {
        type Fsync-bag-source-state;
        description "PTP state";
      }

      leaf supports-frequency {
        type boolean;
        description
          "The PTP clock supports frequency";
      }

      leaf supports-time-of-day {
        type boolean;
        description
          "The PTP clock supports time";
      }

      leaf frequency-priority {
        type Fsync-pri;
        description
          "The priority of the PTP clock when selected
         between frequency sources";
      }

      leaf time-of-day-priority {
        type Fsync-time-pri;
        description
          "The priority of the PTP clock when selecting
         between time-of-day sources";
      }

      list spa-selection-point {
        description "Spa selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list spa-selection-point

      list node-selection-point {
        description "Node selection points";
        uses FSYNC-BAG-SP-INFO;
      }  // list node-selection-point
    }  // grouping FSYNC-PTP-INFO-V2
  }  // submodule Cisco-IOS-XR-ncs4k-freqsync-oper-sub1