submodule Cisco-IOS-XR-ptp-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-ptp-oper {
        prefix Cisco-IOS-XR-ptp-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    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 ptp package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-09-07" {
      description
        "Show command updates for APTS and virtual port";
    }

    revision "2020-02-06" {
      description
        "Added valid flags for receiver clock information, sender clock information and master entry properties.
       2019-12-18
       Added checksum related packet drop reasons and servo status enums.";
    }

    revision "2019-10-01" {
      description
        "Corrected enum names for servo.
       2019-09-30
       Added incompatible packet for non-negotiated setting in packet drop reasons.";
    }

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

    revision "2017-02-02" {
      description "Initial version.";
    }

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

    semver:module-version "2.2.0";
    semver:module-version "2.1.0";
    semver:module-version "2.0.0";
    semver:module-version "1.0.0";

    typedef Ptp-leap-seconds-source {
      type uint8;
      description "Ptp leap seconds source";
    }

    typedef Ptp-clock-leap-seconds {
      type uint8;
      description "Ptp clock leap seconds";
    }

    typedef Ptp-msg-version {
      type uint8;
      description "Ptp msg version";
    }

    typedef Ptp-bag-delay-mechanism {
      type enumeration {
        enum "e2e" {
          value 0;
          description
            "End to end delay mechanism";
        }
        enum "p2p" {
          value 1;
          description
            "Peer to peer delay mechanism";
        }
      }
      description "Delay Mechanism";
    }

    typedef Ptp-platform-servo-status {
      type enumeration {
        enum
          "ptp-platform-servo-status-unknown" {
          value 0;
          description
            "ptp platform servo status unknown";
        }
        enum
          "ptp-platform-servo-status-freerun" {
          value 1;
          description
            "ptp platform servo status freerun";
        }
        enum
          "ptp-platform-servo-status-acquiring" {
          value 2;
          description
            "ptp platform servo status acquiring";
        }
        enum
          "ptp-platform-servo-status-freq-locked" {
          value 3;
          description
            "ptp platform servo status freq locked";
        }
        enum
          "ptp-platform-servo-status-phase-aligned" {
          value 4;
          description
            "ptp platform servo status phase aligned";
        }
        enum
          "ptp-platform-servo-status-hold-over" {
          value 5;
          description
            "ptp platform servo status hold over";
        }
      }
      description
        "Ptp platform servo status";
    }

    typedef Ptp-bag-telecom-clock {
      type enumeration {
        enum "grandmaster" {
          value 0;
          description "Grandmaster";
        }
        enum "boundary" {
          value 1;
          description "Boundary";
        }
        enum "slave" {
          value 2;
          description "Slave";
        }
      }
      description "Telecom Clock";
    }

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

    typedef Ptp-bag-profile {
      type enumeration {
        enum "default" {
          value 0;
          description
            "1588v2 profile (default)";
        }
        enum "g82651" {
          value 1;
          description "G.8265.1 profile";
        }
        enum "g82751" {
          value 2;
          description "G.8275.1 profile";
        }
        enum "g82752" {
          value 3;
          description "G.8275.2 profile";
        }
      }
      description "Profile";
    }

    typedef Ptp-bag-restrict-port-state {
      type enumeration {
        enum "any" {
          value 0;
          description "Any";
        }
        enum "slave-only" {
          value 1;
          description "Slave only";
        }
        enum "master-only" {
          value 2;
          description "Master only";
        }
      }
      description "Restrict Port 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 Ptp-bag-port-state {
      type enumeration {
        enum "initializing" {
          value 0;
          description "Initializing state";
        }
        enum "listen" {
          value 1;
          description "Listen state";
        }
        enum "passive" {
          value 2;
          description "Passive state";
        }
        enum "pre-master" {
          value 3;
          description "Pre-Master state";
        }
        enum "master" {
          value 4;
          description "Master state";
        }
        enum "uncalibrated" {
          value 5;
          description "Uncalibrated state";
        }
        enum "slave" {
          value 6;
          description "Slave state";
        }
        enum "faulty" {
          value 7;
          description "Faulty state";
        }
      }
      description "Port State";
    }

    typedef Ptp-delay-asymmetry {
      type int32;
      description "Ptp delay asymmetry";
    }

    typedef Bag-in6-addr {
      type inet:ipv6-address;
      description "Bag in6 addr";
    }

    typedef Ptp-bag-encap {
      type enumeration {
        enum "unknown" {
          value 0;
          description
            "Unknown encapsulation";
        }
        enum "ethernet" {
          value 1;
          description
            "Ethernet encapsulation";
        }
        enum "ipv4" {
          value 2;
          description "IPv4 encapsulation";
        }
        enum "ipv6" {
          value 3;
          description "IPv6 encapsulation";
        }
      }
      description "Encapsulation";
    }

    typedef Ptp-domain-num {
      type uint8;
      description "Ptp domain num";
    }

    typedef Ptp-bag-communication-model {
      type enumeration {
        enum "unicast" {
          value 0;
          description
            "Unication communication";
        }
        enum "mixed-mode" {
          value 1;
          description
            "Mixed-mode communication";
        }
        enum "multicast" {
          value 2;
          description
            "Multicast communication";
        }
      }
      description "Communication Model";
    }

    typedef Ptp-bag-clock-leap-seconds {
      type enumeration {
        enum "none" {
          value 0;
          description "No leap second";
        }
        enum "leap59" {
          value 1;
          description
            "The last minute of the day has 59 seconds";
        }
        enum "leap61" {
          value 2;
          description
            "The last minute of the day has 61 seconds";
        }
      }
      units "second";
      description "Leap Seconds";
    }

    typedef Ptp-bag-clock-timescale {
      type enumeration {
        enum "ptp" {
          value 0;
          description "PTP timescale";
        }
        enum "arb" {
          value 1;
          description "ARB timescale";
        }
      }
      description "Timescale";
    }

    typedef Ptp-bag-clock-time-source {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "atomic" {
          value 16;
          description "Atomic clock";
        }
        enum "gps" {
          value 32;
          description "GPS clock";
        }
        enum "terrestrial-radio" {
          value 48;
          description "Terrestrial Radio";
        }
        enum "ptp" {
          value 64;
          description
            "Precision Time Protocol";
        }
        enum "ntp" {
          value 80;
          description
            "Network Time Protocol";
        }
        enum "hand-set" {
          value 96;
          description "Hand set";
        }
        enum "other" {
          value 144;
          description "Other Time Source";
        }
        enum "internal-oscillator" {
          value 160;
          description "Internal Oscillator";
        }
      }
      description "Time source";
    }

    typedef Ptp-clock-oslv {
      type uint16;
      description "Ptp clock oslv";
    }

    typedef Ptp-clock-accuracy {
      type uint8;
      description "Ptp clock accuracy";
    }

    typedef Ptp-clock-class {
      type uint8;
      description "Ptp clock class";
    }

    typedef Ptp-clock-priority {
      type uint8;
      description "Ptp clock priority";
    }

    typedef Ptp-clock-id1 {
      type uint64;
      description "Ptp clock id1";
    }

    typedef Ptp-port-num {
      type uint16;
      description "Ptp port num";
    }

    grouping PTP-BAG-LEAP-SECONDS-ENTRY {
      description
        "Upcoming PTP leap-second entry";
      leaf offset {
        type int16;
        units "second";
        description
          "The UTC offset (TAI - UTC), in seconds";
      }

      leaf offset-start-date {
        type uint64;
        description
          "The UNIX timestamp at which the offset becomes
         valid";
      }

      leaf offset-change {
        type int16;
        description
          "The change in UTC offset on applying this offset";
      }

      leaf offset-applied {
        type boolean;
        description
          "Indicates whether the offset has been applied";
      }
    }  // grouping PTP-BAG-LEAP-SECONDS-ENTRY

    grouping PTP-BAG-UTC-OFFSET-INFO {
      description "UTC offset information";
      leaf offset {
        type int16;
        units "second";
        description
          "The UTC offset (TAI - UTC), in seconds";
      }

      leaf valid {
        type boolean;
        description
          "Is the UTC offset valid?";
      }

      leaf flag {
        type Ptp-clock-leap-seconds;
        description
          "Indicates the duration of the final minute of
         the current day";
      }
    }  // grouping PTP-BAG-UTC-OFFSET-INFO

    grouping PTP-LEAP-SECONDS-INFO {
      description
        "PTP UTC offset information";
      container current-offset-info {
        description
          "The current UTC offset information";
        uses PTP-BAG-UTC-OFFSET-INFO;
      }  // container current-offset-info

      container current-gm-offset-info {
        description
          "The UTC offset information recovered from the
         current grandmaster";
        uses PTP-BAG-UTC-OFFSET-INFO;
      }  // container current-gm-offset-info

      container configured-offset-info {
        description
          "The currently configured UTC offset information";
        uses PTP-BAG-UTC-OFFSET-INFO;
      }  // container configured-offset-info

      container previous-gm-offset-info {
        description
          "The UTC offset information recovered from the
         prevous grandmaster";
        uses PTP-BAG-UTC-OFFSET-INFO;
      }  // container previous-gm-offset-info

      container hardware-offset-info {
        description
          "The UTC offset information taken from the
         hardware";
        uses PTP-BAG-UTC-OFFSET-INFO;
      }  // container hardware-offset-info

      container gm-leap-second {
        description
          "The upcoming leap second advertised by the
         grandmaster (if there is one)";
        uses PTP-BAG-LEAP-SECONDS-ENTRY;
      }  // container gm-leap-second

      leaf source-type {
        type Ptp-leap-seconds-source;
        description
          "The current source of the UTC offset information";
      }

      leaf source-file {
        type Ptp-bag-optional-string;
        description
          "The URL of the file containing leap second
         information";
      }

      leaf source-expiry-date {
        type uint32;
        units "second";
        description
          "Source file expiry timestamp, in seconds since
         UNIX epoch";
      }

      leaf polling-frequency {
        type uint32;
        units "day";
        description
          "Source file polling frequency, in days";
      }

      list configured-leap-second {
        description
          "The list of upcoming configured leap second
         updates";
        uses PTP-BAG-LEAP-SECONDS-ENTRY;
      }  // list configured-leap-second
    }  // grouping PTP-LEAP-SECONDS-INFO

    grouping PTP-GRANDMASTER-INFO {
      description
        "Grandmaster clock information";
      container clock-properties {
        description "Grandmaster clock";
        uses PTP-BAG-CLOCK;
      }  // container clock-properties

      container address {
        description
          "The grandmaster's address information";
        uses PTP-BAG-ADDRESS;
      }  // container address

      leaf used-for-time {
        type boolean;
        description
          "Whether the grandmaster is setting time-of-day
         on the system";
      }

      leaf used-for-frequency {
        type boolean;
        description
          "Whether the grandmaster is setting frequency on
         the system";
      }

      leaf known-for-time {
        type uint32;
        units "second";
        description
          "How long the clock has been grandmaster for, in
         seconds";
      }

      leaf domain {
        type Ptp-domain-num;
        description
          "The PTP domain that the grandmaster is in";
      }

      leaf running-drrm {
        type boolean;
        description
          "Whether DRRM is running for the grandmaster";
      }
    }  // grouping PTP-GRANDMASTER-INFO

    grouping PTP-BAG-GL-CONFIG-ERRORS {
      description
        "Global Configuration Errors";
      leaf domain {
        type boolean;
        description
          "Domain not compatible with configured profile";
      }

      leaf profile-priority1-config {
        type boolean;
        description
          "Priority1 configuration is not compatible with
         configured profile";
      }

      leaf profile-priority2-value {
        type boolean;
        description
          "Priority2 value is not compatible with
         configured profile";
      }

      leaf utc-offset-change {
        type boolean;
        description
          "Leap seconds configuration contains an invalid
         UTC offset change";
      }

      leaf physical-layer-frequency {
        type boolean;
        description
          "Physical Layer Frequency configuration is not
         compatible with G.8265.1 profile";
      }

      leaf network-type {
        type boolean;
        description
          "Network type high PDV configuration is only
         compatible with G.8265.1 profile";
      }

      leaf profile-virtual-port {
        type boolean;
        description
          "Virtual Port configuration is not compatible
         with default profile";
      }

      leaf virtual-port-priority1-config {
        type boolean;
        description
          "Virtual Port priority1 configuration is not
         compatible with configured profile";
      }

      leaf virtual-port-priority2-value {
        type boolean;
        description
          "Virtual Port priority2 value is not compatible
         with configured profile";
      }

      leaf virtual-port-profile-clock-class {
        type boolean;
        description
          "Virtual port clock class is not compatible with
         configured profile";
      }

      leaf virtual-port-clock-accuracy {
        type boolean;
        description
          "Virtual port clock accuracy is not compatible
         with configured profile";
      }

      leaf virtual-port-oslv {
        type boolean;
        description
          "Virtual port OSLV is not compatible with
         configured profile";
      }

      leaf virtual-port-local-priority {
        type boolean;
        description
          "Virtual port local priority configuration is not
         compatible with configured profile";
      }

      leaf apts-clock-type {
        type boolean;
        description
          "APTS configuration is not compatible with
         configured clock type";
      }

      leaf apts-clock-profile {
        type boolean;
        description
          "APTS configuration is not compatible with
         configured profile";
      }
    }  // grouping PTP-BAG-GL-CONFIG-ERRORS

    grouping PTP-GL-CONFIG-ERRORS-INFO {
      description
        "Global configuration errors information";
      container configuration-errors {
        description "Configuration Errors";
        uses PTP-BAG-GL-CONFIG-ERRORS;
      }  // container configuration-errors

      leaf clock-profile {
        type Ptp-bag-profile;
        description "The clock profile";
      }

      leaf clock-profile-set {
        type boolean;
        description
          "Is the clock profile set";
      }

      leaf telecom-clock-type {
        type Ptp-bag-telecom-clock;
        description
          "Configured telecom clock type";
      }

      leaf domain-number {
        type Ptp-domain-num;
        description "The PTP domain";
      }

      leaf priority2 {
        type Ptp-clock-priority;
        description
          "The configured priority2 value";
      }

      leaf virtual-port-priority2 {
        type Ptp-clock-priority;
        description
          "The configured priority2 value of the virtual
         port";
      }

      leaf virtual-port-clock-class {
        type Ptp-clock-class;
        description
          "The configured clock class of the virtual port";
      }

      leaf virtual-port-clock-accuracy {
        type Ptp-clock-accuracy;
        description
          "The configured clock accuracy of the virtual
         port";
      }

      leaf virtual-port-oslv {
        type Ptp-clock-oslv;
        description
          "The configured oslv of the virtual port";
      }
    }  // grouping PTP-GL-CONFIG-ERRORS-INFO

    grouping PTP-TIME-PROPERTIES-DS-INFO {
      description
        "timeProprtiesDS information";
      leaf current-utc-offset {
        type int16;
        description "The current UTC offset";
      }

      leaf current-utc-offset-valid {
        type boolean;
        description
          "Whether the current UTC offset is valid";
      }

      leaf leap59 {
        type boolean;
        description
          "Whether the last minute of the day has 59
         seconds";
      }

      leaf leap61 {
        type boolean;
        description
          "Whether the last minute of the day has 61
         seconds";
      }

      leaf time-traceable {
        type boolean;
        description
          "Whether the time-of-day source is traceable";
      }

      leaf frequency-traceable {
        type boolean;
        description
          "Whther the frequency source is traceable";
      }

      leaf ptp-timescale {
        type boolean;
        description
          "Whether the timescale being used is the PTP
         timescale";
      }

      leaf time-source {
        type Ptp-bag-clock-time-source;
        description
          "The physical time-source of the GM clock";
      }
    }  // grouping PTP-TIME-PROPERTIES-DS-INFO

    grouping PTP-PORT-DS-INFO {
      description "portDS information";
      leaf clock-id {
        type Ptp-clock-id1;
        description
          "The ID of the local-clock";
      }

      leaf port-number {
        type Ptp-port-num;
        description "The port number";
      }

      leaf port-state {
        type Ptp-bag-port-state;
        description "The port state";
      }

      leaf log-min-delay-req-interval {
        type int16;
        description
          "The log (base 2) of the minimum delay-request
         interval";
      }

      leaf peer-mean-path-delay {
        type int64;
        description
          "The mean path delay between peers";
      }

      leaf log-announce-interval {
        type int16;
        description
          "The log (base 2) of the announce interval";
      }

      leaf annoucne-receipt-timeout {
        type uint32;
        description "The announce timeout";
      }

      leaf log-sync-interval {
        type int16;
        description
          "The log (base 2) of the sync interval";
      }

      leaf delay-mechanism {
        type Ptp-bag-delay-mechanism;
        description
          "The delay mechanism being used on this port";
      }

      leaf log-min-p-delay-req-interval {
        type int16;
        description
          "The log (base 2) of the minimum
         peer-delay-request interval";
      }

      leaf version-number {
        type Ptp-msg-version;
        description
          "The version of IEEE 1588 being run";
      }

      leaf local-priority {
        type uint32;
        description
          "Local priority of the local clock";
      }

      leaf master-only {
        type boolean;
        description
          "Is the port master-only?";
      }

      leaf signal-fail {
        type boolean;
        description
          "Signal fail status of the port";
      }
    }  // grouping PTP-PORT-DS-INFO

    grouping PTP-PARENT-DS-INFO {
      description "parentDS information";
      leaf parent-clock-id {
        type Ptp-clock-id1;
        description
          "The Clock ID of the parent clock";
      }

      leaf parent-port-number {
        type Ptp-port-num;
        description
          "The port number on which the parent clock is
         received";
      }

      leaf parent-stats {
        type boolean;
        description
          "Whether the parentStats is valid";
      }

      leaf observed-parent-oslv {
        type Ptp-clock-oslv;
        description
          "The observed parent offset scaled log variance";
      }

      leaf observed-parent-clock-phase-change-rate {
        type uint32;
        description
          "The observed rate of change of phase of the
         parent clock";
      }

      leaf gm-clock-id {
        type Ptp-clock-id1;
        description "The Clock ID of the GM";
      }

      leaf gm-clock-class {
        type Ptp-clock-class;
        description
          "The clock class of the GM";
      }

      leaf gm-clock-accuracy {
        type Ptp-clock-accuracy;
        description
          "The clock accuracy of the GM";
      }

      leaf gmoslv {
        type Ptp-clock-oslv;
        description
          "The offset scaled log variance of the GM";
      }

      leaf gm-priority1 {
        type Ptp-clock-priority;
        description
          "The priority1 of the GM";
      }

      leaf gm-priority2 {
        type Ptp-clock-priority;
        description
          "The priority2 of the GM";
      }
    }  // grouping PTP-PARENT-DS-INFO

    grouping PTP-CURRENT-DS-INFO {
      description "currentDS information";
      leaf steps-removed {
        type uint16;
        description
          "How many steps removed this clock is from the GM";
      }

      leaf offset-from-master {
        type int64;
        description
          "The UTC offset of the local-clock from the GM";
      }

      leaf mean-path-delay {
        type int64;
        description
          "The mean path delay between the foreign-master
         and the local-clock";
      }
    }  // grouping PTP-CURRENT-DS-INFO

    grouping PTP-DEFAULT-DS-INFO {
      description "defaultDS information";
      leaf two-step-flag {
        type boolean;
        description
          "Is the twoStepFlag set for this clock";
      }

      leaf clock-id {
        type Ptp-clock-id1;
        description "The local-clock ID";
      }

      leaf number-ports {
        type uint32;
        description
          "The number of active PTP ports on this clock";
      }

      leaf clock-class {
        type Ptp-clock-class;
        description
          "The clock class of the local-clock";
      }

      leaf clock-accuracy {
        type Ptp-clock-accuracy;
        description
          "The accuracy of the local-clock";
      }

      leaf oslv {
        type Ptp-clock-oslv;
        description
          "The offset scaled log variance of the
         local-clock";
      }

      leaf priority1 {
        type Ptp-clock-priority;
        description
          "The priority1 of the local-clock";
      }

      leaf priority2 {
        type Ptp-clock-priority;
        description
          "The priority2 of the local-clock";
      }

      leaf domain-number {
        type Ptp-domain-num;
        description
          "The domain of the local-clock";
      }

      leaf slave-only {
        type boolean;
        description
          "Whether the local-clock is globally configured
         as slave-only";
      }

      leaf local-priority {
        type uint32;
        description
          "Local priority of the local clock";
      }

      leaf signal-fail {
        type boolean;
        description
          "Signal fail status of the local clock";
      }
    }  // grouping PTP-DEFAULT-DS-INFO

    grouping PTP-ADVERTISED-CLOCK-INFO {
      description
        "Advertised clock information";
      container clock-properties {
        description "Advertised Clock";
        uses PTP-BAG-CLOCK;
      }  // container clock-properties

      leaf domain {
        type Ptp-domain-num;
        description
          "The PTP domain of that the advertised clock is
         in";
      }

      leaf time-source-configured {
        type boolean;
        description
          "Whether the advertised time source is configured";
      }

      leaf received-time-source {
        type Ptp-bag-clock-time-source;
        description
          "The time source received from the parent clock";
      }

      leaf timescale-configured {
        type boolean;
        description
          "Whether the advertised timescale is configured";
      }

      leaf received-timescale {
        type Ptp-bag-clock-timescale;
        description
          "The timescale received from the parent clock";
      }
    }  // grouping PTP-ADVERTISED-CLOCK-INFO

    grouping PTP-BAG-PEER-PACKET-COUNTERS {
      description "PTP peer packet counters";
      container address {
        description "Peer address";
        uses PTP-BAG-ADDRESS;
      }  // container address

      container counters {
        description "Packet counters";
        uses PTP-BAG-PACKET-COUNTERS;
      }  // container counters
    }  // grouping PTP-BAG-PEER-PACKET-COUNTERS

    grouping PTP-IF-PACKET-COUNTER-INFO {
      description
        "PTP interface packet counters";
      container counters {
        description "Packet counters";
        uses PTP-BAG-PACKET-COUNTERS;
      }  // container counters

      list peer-counter {
        description
          "Packet counters for each peer on this interface";
        uses PTP-BAG-PEER-PACKET-COUNTERS;
      }  // list peer-counter
    }  // grouping PTP-IF-PACKET-COUNTER-INFO

    grouping PTP-BAG-VIRTUAL-PORT {
      description "PTP Virtual Port";
      leaf configured {
        type boolean;
        description "Configured";
      }

      leaf connected {
        type boolean;
        description "Connected";
      }

      leaf priority1 {
        type Ptp-clock-priority;
        description "Priority 1";
      }

      leaf priority2 {
        type Ptp-clock-priority;
        description "Priority 2";
      }

      leaf class {
        type Ptp-clock-class;
        description "Class";
      }

      leaf accuracy {
        type Ptp-clock-accuracy;
        description "Accuracy";
      }

      leaf offset-log-variance {
        type Ptp-clock-oslv;
        description "Offset log variance";
      }

      leaf local-priority {
        type Ptp-clock-priority;
        description "The local priority";
      }
    }  // grouping PTP-BAG-VIRTUAL-PORT

    grouping PTP-LOCAL-CLOCK-INFO {
      description "Local clock information";
      container clock-properties {
        description "Local clock";
        uses PTP-BAG-CLOCK;
      }  // container clock-properties

      container virtual-port {
        description "Virtual port";
        uses PTP-BAG-VIRTUAL-PORT;
      }  // container virtual-port

      leaf domain {
        type Ptp-domain-num;
        description
          "The PTP domain of the local clock";
      }

      leaf grandmaster {
        type boolean;
        description
          "Whether the local clock is the grandmaster";
      }

      leaf servo-status {
        type Ptp-platform-servo-status;
        description "Servo status";
      }

      leaf mean-path-delay {
        type int64;
        units "nanosecond";
        description
          "Mean path delay of master (nanoseconds)";
      }

      leaf offset-from-master {
        type int64;
        units "nanosecond";
        description
          "Offset from master (nanoseconds)";
      }

      leaf apts-enabled {
        type boolean;
        description
          "Whether assisted partial timing support is
         enabled";
      }
    }  // grouping PTP-LOCAL-CLOCK-INFO

    grouping PTP-BAG-PROFILE-INTEROP {
      description
        "PTP Profile Interop Status";
      leaf from-priority1 {
        type Ptp-clock-priority;
        description "From Priority 1";
      }

      leaf to-priority1 {
        type Ptp-clock-priority;
        description "To Priority 1";
      }

      leaf from-priority2 {
        type Ptp-clock-priority;
        description "From Priority 2";
      }

      leaf to-priority2 {
        type Ptp-clock-priority;
        description "To Priority 2";
      }

      leaf from-accuracy {
        type Ptp-clock-accuracy;
        description "From Accuracy";
      }

      leaf to-accuracy {
        type Ptp-clock-accuracy;
        description "To Accuracy";
      }

      leaf from-clock-class {
        type Ptp-clock-class;
        description "From Clock Class";
      }

      leaf to-clock-class {
        type Ptp-clock-class;
        description "To Clock Class";
      }

      leaf from-offset-log-variance {
        type Ptp-clock-oslv;
        description
          "From Offset log variance";
      }

      leaf to-offset-log-variance {
        type Ptp-clock-oslv;
        description "To Offset log variance";
      }
    }  // grouping PTP-BAG-PROFILE-INTEROP

    grouping PTP-BAG-PROFILE-INTEROP-PEER {
      description
        "PTP Profile Interop Peer Status";
      container address {
        description "Peer address";
        uses PTP-BAG-ADDRESS;
      }  // container address

      container interop {
        description "Interop information";
        uses PTP-BAG-PROFILE-INTEROP;
      }  // container interop
    }  // grouping PTP-BAG-PROFILE-INTEROP-PEER

    grouping PTP-IF-INTEROP-INFO {
      description
        "PTP interface interop information";
      container egress-interop {
        description
          "Egress interop information";
        uses PTP-BAG-PROFILE-INTEROP;
      }  // container egress-interop

      leaf local-domain {
        type Ptp-domain-num;
        description
          "The PTP domain configured for this interface";
      }

      leaf interop-domain {
        type Ptp-domain-num;
        description
          "The PTP domain that is being interoperated with";
      }

      leaf local-profile {
        type Ptp-bag-profile;
        description
          "The PTP Profile configured for this interface";
      }

      leaf interop-profile {
        type Ptp-bag-profile;
        description
          "The PTP profile that is being interoperated with";
      }

      list ingress-interop {
        description
          "Per-peer ingress interop information";
        uses PTP-BAG-PROFILE-INTEROP-PEER;
      }  // list ingress-interop
    }  // grouping PTP-IF-INTEROP-INFO

    grouping PTP-BAG-CONFIG-ERRORS {
      description "Configuration Errors";
      leaf global-ptp {
        type boolean;
        description
          "PTP enabled on interface but not globally";
      }

      leaf ethernet-transport {
        type boolean;
        description
          "Ethernet transport configured but not supported";
      }

      leaf one-step {
        type boolean;
        description
          "One step clock operation configured but not
         supported";
      }

      leaf slave {
        type boolean;
        description
          "Slave-operation configured but not supported";
      }

      leaf ipv6 {
        type boolean;
        description
          "IPv6 transport configured but not supported";
      }

      leaf multicast {
        type boolean;
        description
          "Multicast configured but not supported";
      }

      leaf profile-not-global {
        type boolean;
        description
          "Profile is referenced but not globally
         configured";
      }

      leaf local-priority {
        type boolean;
        description
          "Local priority configuration is not compatible
         with profile";
      }

      leaf profile-ethernet {
        type boolean;
        description
          "Ethernet transport is not compatible with
         profile";
      }

      leaf profile-ipv4 {
        type boolean;
        description
          "IPv6 transport is not compatible with profile";
      }

      leaf profile-ipv6 {
        type boolean;
        description
          "IPv6 transport is not compatible with profile";
      }

      leaf profile-unicast {
        type boolean;
        description
          "Unicast is not compatible with profile";
      }

      leaf profile-multicast {
        type boolean;
        description
          "Multicast is not compatible with profile";
      }

      leaf profile-mixed {
        type boolean;
        description
          "Mixed-mode multicast is not compatible with
         profile";
      }

      leaf profile-master-unicast {
        type boolean;
        description
          "Unicast master is not compatible with profile";
      }

      leaf profile-master-multicast {
        type boolean;
        description
          "Multicast master is not compatible with profile";
      }

      leaf profile-master-mixed {
        type boolean;
        description
          "Mixed-mode multicast master is not compatible
         with profile";
      }

      leaf target-address-ipv4 {
        type boolean;
        description
          "Ethernet multicast target-address is configured,
         but transport is IPv4";
      }

      leaf target-address-ipv6 {
        type boolean;
        description
          "Ethernet multicast target-address is configured,
         but transport is IPv6";
      }

      leaf ipv4ttl {
        type boolean;
        description
          "IPv4 TTL value configured but transport is not
         IPv4";
      }

      leaf ipv6-hop-limit {
        type boolean;
        description
          "IPv6 hop limit value configured but transport is
         not IPv6";
      }

      leaf profile-port-state {
        type boolean;
        description
          "Port state restriction is not compatible with
         telecom clock type";
      }

      leaf profile-announce-interval {
        type boolean;
        description
          "Announce interval is not compatible with profile";
      }

      leaf profile-sync-interval {
        type boolean;
        description
          "Sync interval is not compatible with profile";
      }

      leaf profile-delay-req-interval {
        type boolean;
        description
          "Delay request interval is not compatible with
         profile";
      }

      leaf profile-sync-timeout {
        type boolean;
        description
          "Sync timeout configuration is not compatible
         with profile";
      }

      leaf profile-delay-resp-timeout {
        type boolean;
        description
          "Delay response timeout configuration is not
         compatible with profile";
      }

      leaf invalid-grant-reduction {
        type boolean;
        description
          "Reducing invalid unicast grants is not
         compatible with configured profile";
      }

      leaf invalid-interop-domain {
        type boolean;
        description
          "Domain is not compatible with configured profile
         interop";
      }

      leaf invalid-interop-ingress-clock-class-default {
        type boolean;
        description
          "Ingress conversion clock class default is not
         compatible with configured profile interop";
      }

      leaf invalid-interop-ingress-priority1 {
        type boolean;
        description
          "Ingress conversion priority1 is not compatible
         with configured profile interop";
      }

      leaf invalid-interop-ingress-clock-accuracy {
        type boolean;
        description
          "Ingress conversion clock-accuracy is not
         compatible with configured profile interop";
      }

      leaf invalid-interop-ingress-oslv {
        type boolean;
        description
          "Ingress conversion OSLV not compatible with
         configured profile interop";
      }

      leaf invalid-interop-egress-clock-class-default {
        type boolean;
        description
          "Egress conversion clock class default is not
         compatible with configured profile interop";
      }

      leaf invalid-interop-egress-priority1 {
        type boolean;
        description
          "Egress conversion priority1 is not compatible
         with configured profile interop";
      }

      leaf invalid-interop-egress-priority2 {
        type boolean;
        description
          "Egress conversion priority2 is not compatible
         with configured profile interop";
      }

      leaf invalid-interop-egress-clock-accuracy {
        type boolean;
        description
          "Egress conversion clock-accuracy is not
         compatible with configured profile interop";
      }

      leaf invalid-interop-egress-oslv {
        type boolean;
        description
          "Egress conversion OSLV not compatible with
         configured profile interop";
      }

      leaf invalid-master-config-clock-type {
        type boolean;
        description
          "Master configuration is not compatible with
         configured clock-type";
      }

      leaf invalid-slave-config-clock-type {
        type boolean;
        description
          "Slave configuration is not compatible with
         configured clock-type";
      }

      leaf invalid-master-config-port-state {
        type boolean;
        description
          "Master configuration is not compatible with
         configured port-state";
      }

      leaf invalid-slave-config-port-state {
        type boolean;
        description
          "Slave configuration is not compatible with
         configured port-state";
      }

      leaf delay-asymmetry-config-clock-type {
        type boolean;
        description
          "Delay asymmetry configuration is not compatible
         with configuredclock-type";
      }

      leaf delay-asymmetry-config-port-state {
        type boolean;
        description
          "Delay asymmetry configuration is not compatible
         with configuredport-state";
      }

      leaf-list invalid-interop-ingress-clock-class-map-from-val {
        type Ptp-clock-class;
        description
          "List of ingress conversion clock class mapping
         'from values' that are not compatible with the
         configure profile interop";
      }

      leaf-list invalid-interop-ingress-clock-class-map-to-val {
        type Ptp-clock-class;
        description
          "List of ingress conversion clock class mapping
         'to values' that are not compatible with the
         configure profile interop";
      }

      leaf-list invalid-interop-egress-clock-class-map-from-val {
        type Ptp-clock-class;
        description
          "List of egress conversion clock class mapping
         'from values' that are not compatible with the
         configure profile interop";
      }

      leaf-list invalid-interop-egress-clock-class-map-to-val {
        type Ptp-clock-class;
        description
          "List of egress conversion clock class mapping
         'to values' that are not compatible with the
         configure profile interop";
      }
    }  // grouping PTP-BAG-CONFIG-ERRORS

    grouping PTP-IF-CONFIG-ERRORS-ENTRY {
      description
        "Configuration Errors Entry";
      container configuration-errors {
        description "Configuration Errors";
        uses PTP-BAG-CONFIG-ERRORS;
      }  // container configuration-errors

      leaf configuration-profile-name {
        type Ptp-bag-optional-string;
        description
          "Configuration profile name, if a profile is
         selected";
      }

      leaf clock-profile {
        type Ptp-bag-profile;
        description "The clock profile";
      }

      leaf telecom-clock-type {
        type Ptp-bag-telecom-clock;
        description "The telecom clock type";
      }

      leaf restrict-port-state {
        type Ptp-bag-restrict-port-state;
        description
          "Restriction on the port state";
      }

      leaf interop-profile {
        type Ptp-bag-profile;
        description
          "The clock profile to interoperate with, if
         interoperation is configured";
      }
    }  // grouping PTP-IF-CONFIG-ERRORS-ENTRY

    grouping PTP-BAG-DROP-REASONS {
      description "Drop Reasons";
      leaf not-ready {
        type uint32;
        description "Not ready for packets";
      }

      leaf wrong-domain {
        type uint32;
        description "Wrong domain number";
      }

      leaf too-short {
        type uint32;
        description "Packet too short";
      }

      leaf looped-same-port {
        type uint32;
        description
          "Local packet received, same port number";
      }

      leaf looped-higher-port {
        type uint32;
        description
          "Local packet received, higher port number";
      }

      leaf looped-lower-port {
        type uint32;
        description
          "Local packet received, lower port number";
      }

      leaf no-timestamp {
        type uint32;
        description
          "No timestamp received with packet";
      }

      leaf zero-timestamp {
        type uint32;
        description
          "Zero timestamp received with packet";
      }

      leaf invalid-tl-vs {
        type uint32;
        description
          "Invalid TLVs received in packet";
      }

      leaf not-for-us {
        type uint32;
        description "Packet not for us";
      }

      leaf not-listening {
        type uint32;
        description
          "Not listening for packets on this interface";
      }

      leaf wrong-master {
        type uint32;
        description
          "Packet from incorrect master";
      }

      leaf unknown-master {
        type uint32;
        description
          "Packet from unknown master";
      }

      leaf not-master {
        type uint32;
        description
          "Packet only handled in Master state";
      }

      leaf not-slave {
        type uint32;
        description
          "Packet only handled in Slave state";
      }

      leaf not-granted {
        type uint32;
        description
          "Packet from peer not granted unicast";
      }

      leaf too-slow {
        type uint32;
        description
          "Packet received too late";
      }

      leaf invalid-packet {
        type uint32;
        description
          "Invalid packet or packet metadata";
      }

      leaf wrong-sequence-id {
        type uint32;
        description "Unexpected sequence ID";
      }

      leaf no-offload-session {
        type uint32;
        description "No offload session";
      }

      leaf not-supported {
        type uint32;
        description
          "PTP packet type not supported";
      }

      leaf min-clock-class {
        type uint32;
        description
          "Clock class below minimum";
      }

      leaf bad-clock-class {
        type uint32;
        description
          "Illegal clock class (255) in announce messages";
      }

      leaf reserved-clock-id {
        type uint32;
        description "Reserved Clock ID";
      }

      leaf steps-removed {
        type uint32;
        description "Steps removed too high";
      }

      leaf g8265-1-incompatible {
        type uint32;
        description
          "Packet not compatible with G.8265.1 profile";
      }

      leaf g8275-1-incompatible {
        type uint32;
        description
          "Packet not compatible with G.8275.1 profile";
      }

      leaf g8275-2-incompatible {
        type uint32;
        description
          "Packet not compatible with G.8275.2 profile";
      }

      leaf incorrect-address {
        type uint32;
        description
          "Packet sent to incorrect address";
      }

      leaf non-negotiated {
        type uint32;
        description
          "Packet not compatible with non-negotiated";
      }

      leaf verify-checksum-failed {
        type uint32;
        description
          "Packet IPv6 UDP checksum check failed";
      }

      leaf ipv4-verify-checksum {
        type uint32;
        description
          "IPv4 packet has corrupted checksum";
      }
    }  // grouping PTP-BAG-DROP-REASONS

    grouping PTP-BAG-PACKET-COUNTERS {
      description "PTP packet counters";
      leaf announce-sent {
        type uint32;
        description
          "Number of announce packets sent";
      }

      leaf announce-received {
        type uint32;
        description
          "Number of announce packets received";
      }

      leaf announce-dropped {
        type uint32;
        description
          "Number of announce packets dropped";
      }

      leaf sync-sent {
        type uint32;
        description
          "Number of sync packets sent";
      }

      leaf sync-received {
        type uint32;
        description
          "Number of sync packets received";
      }

      leaf sync-dropped {
        type uint32;
        description
          "Number of sync packetsdropped";
      }

      leaf follow-up-sent {
        type uint32;
        description
          "Number of follow-up packets sent";
      }

      leaf follow-up-received {
        type uint32;
        description
          "Number of follow-up packets received";
      }

      leaf follow-up-dropped {
        type uint32;
        description
          "Number of follow-up packets dropped";
      }

      leaf delay-request-sent {
        type uint32;
        description
          "Number of delay-request packets sent";
      }

      leaf delay-request-received {
        type uint32;
        description
          "Number of delay-request packets received";
      }

      leaf delay-request-dropped {
        type uint32;
        description
          "Number of delay-request packets dropped";
      }

      leaf delay-response-sent {
        type uint32;
        description
          "Number of delay-response packets sent";
      }

      leaf delay-response-received {
        type uint32;
        description
          "Number of delay-response packets received";
      }

      leaf delay-response-dropped {
        type uint32;
        description
          "Number of delay-response packets dropped";
      }

      leaf peer-delay-request-sent {
        type uint32;
        description
          "Number of peer-delay-request packets sent";
      }

      leaf peer-delay-request-received {
        type uint32;
        description
          "Number of peer-delay-request packets received";
      }

      leaf peer-delay-request-dropped {
        type uint32;
        description
          "Number of peer-delay-request packets dropped";
      }

      leaf peer-delay-response-sent {
        type uint32;
        description
          "Number of peer-delay-response packets sent";
      }

      leaf peer-delay-response-received {
        type uint32;
        description
          "Number of peer-delay-response packets received";
      }

      leaf peer-delay-response-dropped {
        type uint32;
        description
          "Number of peer-delay-response packets dropped";
      }

      leaf peer-delay-response-follow-up-sent {
        type uint32;
        description
          "Number of peer-delay-response follow-up packets
         sent";
      }

      leaf peer-delay-response-follow-up-received {
        type uint32;
        description
          "Number of peer-delay-response follow-up packets
         received";
      }

      leaf peer-delay-response-follow-up-dropped {
        type uint32;
        description
          "Number of peer-delay-response follow-up packets
         dropped";
      }

      leaf signaling-sent {
        type uint32;
        description
          "Number of signaling packets sent";
      }

      leaf signaling-received {
        type uint32;
        description
          "Number of signaling packets received";
      }

      leaf signaling-dropped {
        type uint32;
        description
          "Number of signaling packets dropped";
      }

      leaf management-sent {
        type uint32;
        description
          "Number of management messages sent";
      }

      leaf management-received {
        type uint32;
        description
          "Number of management messages received";
      }

      leaf management-dropped {
        type uint32;
        description
          "Number of management messages dropped";
      }

      leaf other-packets-sent {
        type uint32;
        description
          "Number of other packets sent";
      }

      leaf other-packets-received {
        type uint32;
        description
          "Number of other packets received";
      }

      leaf other-packets-dropped {
        type uint32;
        description
          "Number of other packets dropped";
      }

      leaf total-packets-sent {
        type uint32;
        description
          "Total number of packets sent";
      }

      leaf total-packets-received {
        type uint32;
        description
          "Total number of packets received";
      }

      leaf total-packets-dropped {
        type uint32;
        description
          "Total number of packets dropped";
      }
    }  // grouping PTP-BAG-PACKET-COUNTERS

    grouping PTP-NODE-PACKET-COUNTER-INFO {
      description "PTP node packet counters";
      container counters {
        description "Packet counters";
        uses PTP-BAG-PACKET-COUNTERS;
      }  // container counters

      container drop-reasons {
        description "Drop reasons";
        uses PTP-BAG-DROP-REASONS;
      }  // container drop-reasons
    }  // grouping PTP-NODE-PACKET-COUNTER-INFO

    grouping PTP-BAG-UNICAST-PEER {
      description "PTP Unicast Peer";
      container address {
        description
          "The address of the unicast peer";
        uses PTP-BAG-ADDRESS;
      }  // container address

      container announce-grant {
        description
          "Unicast grant information for announce messages";
        uses PTP-BAG-UNICAST-GRANT;
      }  // container announce-grant

      container sync-grant {
        description
          "Unicast grant information for sync messages";
        uses PTP-BAG-UNICAST-GRANT;
      }  // container sync-grant

      container delay-response-grant {
        description
          "Unicast grant information for delay-response
         messages";
        uses PTP-BAG-UNICAST-GRANT;
      }  // container delay-response-grant
    }  // grouping PTP-BAG-UNICAST-PEER

    grouping PTP-IF-UNICAST-PEER-INFO {
      description
        "PTP interface unicast peers";
      leaf name {
        type string;
        description "Interface name";
      }

      leaf port-number {
        type Ptp-port-num;
        description "Port number";
      }

      list peers {
        description "Unicast Peers";
        uses PTP-BAG-UNICAST-PEER;
      }  // list peers

      list foreign-master {
        description
          "Unicast Foreign Masters";
        uses PTP-BAG-UNICAST-PEER;
      }  // list foreign-master
    }  // grouping PTP-IF-UNICAST-PEER-INFO

    grouping PTP-BAG-CLOCK-CLASS-MAPPING {
      description "PTP Clock Class Mapping";
      leaf from-clock-class {
        type Ptp-clock-class;
        description "From clock class";
      }

      leaf to-clock-class {
        type Ptp-clock-class;
        description "To clock class";
      }
    }  // grouping PTP-BAG-CLOCK-CLASS-MAPPING

    grouping PTP-BAG-PROFILE-INTEROP-CFG {
      description
        "PTP Profile Interop Configuration";
      leaf priority1 {
        type Ptp-clock-priority;
        description "Priority 1";
      }

      leaf priority2 {
        type Ptp-clock-priority;
        description "Priority 2";
      }

      leaf accuracy {
        type Ptp-clock-accuracy;
        description "Accuracy";
      }

      leaf class-default {
        type Ptp-clock-class;
        description "Class Default";
      }

      leaf offset-log-variance {
        type Ptp-clock-oslv;
        description "Offset log variance";
      }

      list class-mapping {
        description "Class Mapping";
        uses PTP-BAG-CLOCK-CLASS-MAPPING;
      }  // list class-mapping
    }  // grouping PTP-BAG-PROFILE-INTEROP-CFG

    grouping PTP-BAG-MASTER-TABLE-ENTRY {
      description "PTP Master Table Entry";
      container address {
        description
          "The address of the master clock";
        uses PTP-BAG-ADDRESS;
      }  // container address

      leaf communication-model {
        type Ptp-bag-communication-model;
        description
          "The configured communication model of the master
         clock";
      }

      leaf priority {
        type uint8;
        description
          "The priority of the master clock, if it is set";
      }

      leaf known {
        type boolean;
        description
          "Whether the interface is receiving messages from
         this master";
      }

      leaf is-knownvalid {
        type boolean;
        description
          "Does the known boolean contain valid information";
      }

      leaf qualified {
        type boolean;
        description
          "The master is qualified for best master clock
         selection";
      }

      leaf is-qualified-valid {
        type boolean;
        description
          "Does the Qualified boolean contain valid
         information";
      }

      leaf is-grandmaster {
        type boolean;
        description
          "Whether this is the grandmaster";
      }

      leaf is-is-grandmaster-valid {
        type boolean;
        description
          "Does the IsGrandmaster boolean contain valid
         information";
      }

      leaf ptsf-loss-announce {
        type uint8;
        description
          "Announced messages are not being received from
         the master";
      }

      leaf ptsf-loss-sync {
        type uint8;
        description
          "Sync messages are not being received from the
         master";
      }

      leaf are-ptsf-valid {
        type boolean;
        description
          "Do the PTSF values contain valid information";
      }

      leaf is-nonnegotiated {
        type boolean;
        description
          "Whether this master uses non-negotiated unicast";
      }
    }  // grouping PTP-BAG-MASTER-TABLE-ENTRY

    grouping PTP-BAG-IPV4-ADDR-LIST {
      description "List of IPv4 addresses";
      leaf-list addr {
        type inet:ipv4-address;
        description "List of IPv4 addresses";
      }
    }  // grouping PTP-BAG-IPV4-ADDR-LIST

    grouping PTP-BAG-IPV6-ADDR-LIST {
      description "List of IPv6 addresses";
      leaf-list addr {
        type Bag-in6-addr;
        description "List of IPv6 addresses";
      }
    }  // grouping PTP-BAG-IPV6-ADDR-LIST

    grouping PTP-IF-INFO {
      description
        "PTP interface information";
      container ipv6-address-array {
        description
          "List of Ipv6 addresses, if IPv6 encapsulation is
         being used. If a source address is configured,
         this is the only item in the list";
        uses PTP-BAG-IPV6-ADDR-LIST;
      }  // container ipv6-address-array

      container ipv4-address-array {
        description
          "List of IPv4 addresses, if IPv4 encapsulation is
         being used. The first address is the primary
         address. If a source address is configured, this
         is the only item in the list.";
        uses PTP-BAG-IPV4-ADDR-LIST;
      }  // container ipv4-address-array

      container mac-address {
        description
          "MAC address, if Ethernet encapsulation is being
         used";
        uses PTP-BAG-MAC-ADDR-TYPE;
      }  // container mac-address

      container ingress-conversion {
        description
          "Details of any ingress conversion";
        uses PTP-BAG-PROFILE-INTEROP-CFG;
      }  // container ingress-conversion

      container egress-conversion {
        description
          "Details of any egress conversion";
        uses PTP-BAG-PROFILE-INTEROP-CFG;
      }  // container egress-conversion

      leaf port-state {
        type Ptp-bag-port-state;
        description "Port state";
      }

      leaf port-number {
        type Ptp-port-num;
        description "Port number";
      }

      leaf line-state {
        type Im-state-enum;
        description "Line state";
      }

      leaf interface-type {
        type string;
        description "Interface Type";
      }

      leaf encapsulation {
        type Ptp-bag-encap;
        description "Encapsulation";
      }

      leaf ipv6-address {
        type Bag-in6-addr;
        description
          "Ipv6 source address for interface running PTP,
         if IPv6 encapsulation is being used";
      }

      leaf ipv4-address {
        type inet:ipv4-address;
        description
          "IPv4 source address for interface running PTP,
         if IPv4 encapsulation is being used";
      }

      leaf two-step {
        type boolean;
        description
          "Two step delay-request mechanism is being used";
      }

      leaf communication-model {
        type Ptp-bag-communication-model;
        description
          "Communication model configured on the interface";
      }

      leaf log-sync-interval {
        type int32;
        description
          "Log of the interface's sync interval";
      }

      leaf log-announce-interval {
        type int32;
        description
          "Log of the interface's announce interval";
      }

      leaf announce-timeout {
        type uint32;
        description "Announce timeout";
      }

      leaf log-min-delay-request-interval {
        type int32;
        description
          "Log of the interface's Minimum delay-request
         interval";
      }

      leaf configured-port-state {
        type Ptp-bag-restrict-port-state;
        description
          "The configured port state";
      }

      leaf supports-unicast {
        type boolean;
        description
          "The interface supports unicast";
      }

      leaf supports-master {
        type boolean;
        description
          "The interface supports operation in master mode";
      }

      leaf supports-one-step {
        type boolean;
        description
          "The interface supports one-step operation";
      }

      leaf supports-two-step {
        type boolean;
        description
          "The interface supports two-step operation";
      }

      leaf supports-ethernet {
        type boolean;
        description
          "The interface supports ethernet transport";
      }

      leaf supports-multicast {
        type boolean;
        description
          "The interface supports multicast";
      }

      leaf supports-ipv4 {
        type boolean;
        description
          "The interface supports IPv4 transport";
      }

      leaf supports-ipv6 {
        type boolean;
        description
          "The interface supports IPv6 transport";
      }

      leaf supports-slave {
        type boolean;
        description
          "The interface supports operation in slave mode";
      }

      leaf supports-source-ip {
        type boolean;
        description
          "The interface supports source ip configuration";
      }

      leaf max-sync-rate {
        type uint8;
        description
          "The maximum rate of sync packets on the
         interface";
      }

      leaf event-cos {
        type uint32;
        description
          "The class of service used on the interface for
         event messages";
      }

      leaf general-cos {
        type uint32;
        description
          "The class of service used on the interface for
         general messages";
      }

      leaf event-dscp {
        type uint32;
        description
          "The DSCP class used on the interface for event
         messages";
      }

      leaf general-dscp {
        type uint32;
        description
          "The DSCP class used on the interface for general
         messages";
      }

      leaf unicast-peers {
        type uint32;
        description
          "The number of unicast peers known by the
         interface";
      }

      leaf local-priority {
        type uint8;
        description
          "Local priority, for the G.8275.1 PTP profile";
      }

      leaf signal-fail {
        type boolean;
        description
          "Signal fail status of the interface";
      }

      leaf profile-interop {
        type boolean;
        description
          "Indicate whether profile interop is in use";
      }

      leaf supports-bvi-slave {
        type boolean;
        description
          "The node supports BVI interfaces as Slaves";
      }

      leaf interop-domain {
        type Ptp-domain-num;
        description
          "The PTP domain that is being interoperated with";
      }

      leaf interop-profile {
        type Ptp-bag-profile;
        description
          "Profile that is being interoperated with";
      }

      list master-table {
        description
          "The interface's master table";
        uses PTP-BAG-MASTER-TABLE-ENTRY;
      }  // list master-table
    }  // grouping PTP-IF-INFO

    grouping PTP-SUMMARY-INFO {
      description "PTP summary information";
      leaf port-state-init-count {
        type uint32;
        description
          "Number of interfaces in 'Init' port state";
      }

      leaf port-state-listening-count {
        type uint32;
        description
          "Number of interfaces in 'Listening' port state";
      }

      leaf port-state-passive-count {
        type uint32;
        description
          "Number of interfaces in 'Passive' port state";
      }

      leaf port-state-pre-master-count {
        type uint32;
        description
          "Number of interfaces in 'Pre-Master' port state";
      }

      leaf port-state-master-count {
        type uint32;
        description
          "Number of interfaces in 'Master' port state";
      }

      leaf port-state-slave-count {
        type uint32;
        description
          "Number of interfaces in 'Slave' port state";
      }

      leaf port-state-uncalibrated-count {
        type uint32;
        description
          "Number of interfaces in 'Uncalibrated port state";
      }

      leaf port-state-faulty-count {
        type uint32;
        description
          "Number of interfaces in 'Faulty' port state";
      }

      leaf total-interfaces {
        type uint32;
        description
          "Total number of interfaces";
      }

      leaf total-interfaces-valid-port-num {
        type uint32;
        description
          "Total number of interfaces with a valid port
         number";
      }
    }  // grouping PTP-SUMMARY-INFO

    grouping PTP-BAG-UNICAST-GRANT {
      description "PTP Unicast Grant";
      leaf log-grant-interval {
        type int8;
        description
          "Log of the interval which has been granted";
      }

      leaf grant-duration {
        type uint32;
        description "Duraction of the grant";
      }
    }  // grouping PTP-BAG-UNICAST-GRANT

    grouping PTP-BAG-IPV6-ADDR-TYPE {
      description "PTP BAG IPV6 ADDR TYPE";
      leaf ipv6-address {
        type Bag-in6-addr;
        description "IPv6 Address";
      }
    }  // grouping PTP-BAG-IPV6-ADDR-TYPE

    grouping PTP-BAG-MAC-ADDR-TYPE {
      description "Mac Address";
      leaf macaddr {
        type yang:mac-address;
        description "macaddr";
      }
    }  // grouping PTP-BAG-MAC-ADDR-TYPE

    grouping PTP-BAG-ADDRESS {
      description "Address";
      container mac-address {
        when "../encapsulation = 'ethernet'" {
          description
            "../Encapsulation = 'Ethernet'";
        }
        description "Ethernet MAC address";
        uses PTP-BAG-MAC-ADDR-TYPE;
      }  // container mac-address

      container ipv6-address {
        when "../encapsulation = 'ipv6'" {
          description
            "../Encapsulation = 'IPv6'";
        }
        description "IPv6 address";
        uses PTP-BAG-IPV6-ADDR-TYPE;
      }  // container ipv6-address

      leaf encapsulation {
        type Ptp-bag-encap;
        description "Encapsulation";
      }

      leaf address-unknown {
        when "../encapsulation = 'unknown'" {
          description
            "../Encapsulation = 'Unknown'";
        }
        type boolean;
        description "Unknown address type";
      }

      leaf ipv4-address {
        when "../encapsulation = 'ipv4'" {
          description
            "../Encapsulation = 'IPv4'";
        }
        type inet:ipv4-address;
        description "IPv4 address";
      }
    }  // grouping PTP-BAG-ADDRESS

    grouping PTP-BAG-PORT-ID {
      description "Port ID";
      leaf clock-id {
        type Ptp-clock-id1;
        description "Clock ID";
      }

      leaf port-number {
        type Ptp-port-num;
        description "Port number";
      }
    }  // grouping PTP-BAG-PORT-ID

    grouping PTP-BAG-CLOCK-UTC-OFFSET {
      description "PTP Clock UTC offset";
      leaf current-offset {
        type int16;
        description "Current offset";
      }

      leaf offset-valid {
        type boolean;
        description
          "The current offset is valid";
      }
    }  // grouping PTP-BAG-CLOCK-UTC-OFFSET

    grouping PTP-BAG-CLOCK {
      description "PTP Clock";
      container utc-offset {
        description "UTC offset";
        uses PTP-BAG-CLOCK-UTC-OFFSET;
      }  // container utc-offset

      container receiver {
        description "Receiver";
        uses PTP-BAG-PORT-ID;
      }  // container receiver

      container sender {
        description "Sender";
        uses PTP-BAG-PORT-ID;
      }  // container sender

      leaf clock-id {
        type Ptp-clock-id1;
        description "Clock ID";
      }

      leaf priority1 {
        type Ptp-clock-priority;
        description "Priority 1";
      }

      leaf priority2 {
        type Ptp-clock-priority;
        description "Priority 2";
      }

      leaf class {
        type Ptp-clock-class;
        description "Class";
      }

      leaf accuracy {
        type Ptp-clock-accuracy;
        description "Accuracy";
      }

      leaf offset-log-variance {
        type Ptp-clock-oslv;
        description "Offset log variance";
      }

      leaf steps-removed {
        type uint16;
        description "Steps removed";
      }

      leaf time-source {
        type Ptp-bag-clock-time-source;
        description "Time source";
      }

      leaf frequency-traceable {
        type boolean;
        description
          "The clock is frequency traceable";
      }

      leaf time-traceable {
        type boolean;
        description
          "The clock is time traceable";
      }

      leaf timescale {
        type Ptp-bag-clock-timescale;
        description "Timescale";
      }

      leaf leap-seconds {
        type Ptp-bag-clock-leap-seconds;
        units "second";
        description "Leap Seconds";
      }

      leaf is-receiver-valid {
        type boolean;
        description
          "Is the receiver information valid";
      }

      leaf is-sender-valid {
        type boolean;
        description
          "Is the sender information valid";
      }

      leaf local {
        type boolean;
        description
          "The clock is the local clock";
      }

      leaf configured-clock-class {
        type Ptp-clock-class;
        description
          "The configured clock class";
      }

      leaf configured-priority {
        type Ptp-clock-priority;
        description
          "The configured priority";
      }
    }  // grouping PTP-BAG-CLOCK

    grouping PTP-BAG-FOREIGN-CLOCK {
      description "PTP Foreign Clock";
      container foreign-clock {
        description
          "Foreign clock information";
        uses PTP-BAG-CLOCK;
      }  // container foreign-clock

      container address {
        description
          "The address of the clock";
        uses PTP-BAG-ADDRESS;
      }  // container address

      container announce-grant {
        description
          "Unicast grant information for announce messages";
        uses PTP-BAG-UNICAST-GRANT;
      }  // container announce-grant

      container sync-grant {
        description
          "Unicast grant information for sync messages";
        uses PTP-BAG-UNICAST-GRANT;
      }  // container sync-grant

      container delay-response-grant {
        description
          "Unicast grant information for delay-response
         messages";
        uses PTP-BAG-UNICAST-GRANT;
      }  // container delay-response-grant

      leaf is-qualified {
        type boolean;
        description
          "The clock is qualified for best master clock
         selection";
      }

      leaf is-grandmaster {
        type boolean;
        description
          "This clock is the currently selected grand
         master clock";
      }

      leaf communication-model {
        type Ptp-bag-communication-model;
        description
          "The communication model configured on this clock";
      }

      leaf is-known {
        type boolean;
        description
          "This clock is known by this router";
      }

      leaf time-known-for {
        type uint32;
        units "second";
        description
          "How long the clock has been known by this router
         for, in seconds";
      }

      leaf foreign-domain {
        type Ptp-domain-num;
        description
          "The PTP domain that the foreign clock is in";
      }

      leaf configured-priority {
        type Ptp-clock-priority;
        description
          "Priority configured for the clock, if any";
      }

      leaf configured-clock-class {
        type Ptp-clock-class;
        description
          "Clock class configured for the clock, if any";
      }

      leaf delay-asymmetry {
        type Ptp-delay-asymmetry;
        description
          "Delay asymmetry configured for the clock, if any";
      }

      leaf ptsf-loss-announce {
        type boolean;
        description
          "Announced messages are not being received from
         the master";
      }

      leaf ptsf-loss-sync {
        type boolean;
        description
          "Sync messages are not being received from the
         master";
      }

      leaf is-dnu {
        type boolean;
        description
          "The clock has clock class corresponding to
         QL-DNU";
      }
    }  // grouping PTP-BAG-FOREIGN-CLOCK

    grouping PTP-IF-CLOCK-INFO {
      description
        "PTP foreign clock information";
      leaf port-number {
        type Ptp-port-num;
        description "Port number";
      }

      list foreign-clock {
        description
          "Foreign clocks received on this interface";
        uses PTP-BAG-FOREIGN-CLOCK;
      }  // list foreign-clock
    }  // grouping PTP-IF-CLOCK-INFO
  }  // submodule Cisco-IOS-XR-ptp-oper-sub1