module Cisco-IOS-XR-ethernet-cfm-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-ethernet-cfm-cfg";

    prefix ethernet-cfm-cfg;

    import ietf-yang-types {
      prefix yang;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }
    import Cisco-IOS-XR-ethernet-cfm-datatypes {
      prefix dt1;
    }
    import Cisco-IOS-XR-infra-sla-datatypes {
      prefix dt2;
    }
    import Cisco-IOS-XR-ifmgr-cfg {
      prefix a1;
    }
    import Cisco-IOS-XR-l2-eth-infra-cfg {
      prefix a2;
    }
    import Cisco-IOS-XR-snmp-agent-cfg {
      prefix a3;
    }
    import Cisco-IOS-XR-infra-sla-cfg {
      prefix a4;
    }

    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 module contains a collection of YANG definitions
     for Cisco IOS-XR ethernet-cfm package configuration.
     
     This YANG module augments the
       Cisco-IOS-XR-ifmgr-cfg,
       Cisco-IOS-XR-l2-eth-infra-cfg,
       Cisco-IOS-XR-snmp-agent-cfg,
       Cisco-IOS-XR-infra-sla-cfg
     modules with configuration data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-10-07" {
      description
        "Added the Link Loss Forwarding feature.";
    }

    revision "2019-10-02" {
      description
        "Add config support for bandwidth notifications";
    }

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

    revision "2018-07-27" {
      description
        "Made bins-width mandatory";
    }

    revision "2017-10-06" {
      description
        "SLA thresholds and actions schema/yang added.";
    }

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

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

    typedef Cfm-mip-policy {
      type enumeration {
        enum "all" {
          value 2;
          description
            "Create MIPs on all ports in the Bridge Domain
           or Cross-connect";
        }
        enum "lower-mep-only" {
          value 3;
          description
            "Create MIPs on ports which have a MEP at a
           lower level";
        }
      }
      description "Cfm mip policy";
    }

    typedef Cfm-service {
      type enumeration {
        enum "bridge-domain" {
          value 1;
          description
            "Use a Bridge Domain - all MEPs will be Up MEPs
           and MIPs are permitted";
        }
        enum "p2p-cross-connect" {
          value 2;
          description
            "Use a P2P Cross Connect - all MEPs will be Up
           MEPs and MIPs are permitted";
        }
        enum "mp2mp-cross-connect" {
          value 3;
          description
            "Use a MP2MP Cross Connect - all MEPs will be Up
           MEPs and MIPs are permitted";
        }
        enum
          "vlan-aware-flexible-cross-connect" {
          value 4;
          description
            "Use a VLAN-aware Flexible Cross Connect - all
           MEPs will be Up MEPs and MIPs are permitted";
        }
        enum
          "vlan-unaware-flexible-cross-connect" {
          value 5;
          description
            "Use a VLAN-unaware Flexible Cross Connect - all
           MEPs will be Up MEPs and MIPs are permitted";
        }
        enum "down-meps" {
          value 6;
          description
            "Down MEPs - no MIPs permitted";
        }
      }
      description "Cfm service";
    }

    typedef Cfm-short-ma-name-format {
      type enumeration {
        enum "vlan-id" {
          value 1;
          description "VLAN ID";
        }
        enum "string" {
          value 2;
          description "String Short MA Name";
        }
        enum "number" {
          value 3;
          description
            "Numeric Short MA Name";
        }
        enum "vpn-id" {
          value 4;
          description "RFC 2685 VPN ID";
        }
        enum "icc-based" {
          value 32;
          description "ICC-based format";
        }
      }
      description "Cfm short ma name format";
    }

    typedef Cfm-lm-counters-cfg {
      type enumeration {
        enum "aggregate" {
          value 1;
          description "Aggregate Counters";
        }
        enum "list" {
          value 2;
          description
            "List of per-CoS counters";
        }
        enum "range" {
          value 3;
          description
            "Range of per-CoS counters";
        }
      }
      description "Cfm lm counters cfg";
    }

    typedef Cfm-mdid-format {
      type enumeration {
        enum "null" {
          value 1;
          description "Null MDID";
        }
        enum "dns-like" {
          value 2;
          description "DNS-like MDID";
        }
        enum "mac-address" {
          value 3;
          description
            "MDID Comprising MAC Address and 16-bit integer";
        }
        enum "string" {
          value 4;
          description "String MDID";
        }
      }
      description "Cfm mdid format";
    }

    augment /a4:sla/a4:protocols {
      description
        "This augment extends the configuration data of
       'Cisco-IOS-XR-infra-sla-cfg'";
      container ethernet {
        description
          "The Ethernet SLA protocol";
        container profiles {
          description
            "Table of SLA profiles on the protocol";
          list profile {
            key "profile-name";
            description
              "Name of the profile";
            container statistics {
              description
                "Statistics configuration for the SLA profile";
              list statistic {
                key "statistic-name";
                description
                  "Type of statistic";
                container buckets-size {
                  presence
                    "Indicates a buckets-size node is configured.";
                  description
                    "Size of the buckets into which statistics
                   are collected";
                  leaf buckets-size {
                    type uint32 {
                      range "1..100";
                    }
                    mandatory true;
                    description
                      "Size of each bucket";
                  }

                  leaf buckets-size-unit {
                    type dt2:Sla-buckets-size-units-enum;
                    mandatory true;
                    description
                      "Unit associated with the BucketsSize";
                  }
                }  // container buckets-size

                container actions {
                  description
                    "Thresholds and associated actions for the
                   given statistics type";
                  list action {
                    key "threshold-type action-type condition";
                    description
                      "Action to perform when the threshold is
                     crossed";
                    leaf threshold-type {
                      type dt2:Sla-threshold-type-enum;
                      description
                        "Threshold type";
                    }

                    leaf action-type {
                      type dt1:Sla-action-type-enum;
                      description
                        "Action to take when the threshold is
                       crossed";
                    }

                    leaf condition {
                      type dt2:Sla-threshold-condition-enum;
                      description
                        "Condition to be met to consider the
                       threshold crossed";
                    }

                    leaf threshold-value {
                      type uint32 {
                        range
                          "1..2147483647";
                      }
                      mandatory true;
                      description
                        "Threshold Value";
                    }

                    leaf bin-number {
                      type uint32 {
                        range "2..100";
                      }
                      description
                        "Bin number in-and-above which samples
                       contribute towards a sample-count
                       threshold (required only when Condition
                       is SampleCount)";
                    }
                  }  // list action
                }  // container actions

                container aggregation {
                  description
                    "Aggregation to apply to results for the
                   statistic";
                  leaf bins-count {
                    type uint32 {
                      range "0..100";
                    }
                    description
                      "Number of bins to aggregate results into
                     (0 for no aggregation)";
                  }

                  leaf bins-width {
                    when
                      "../bins-count != 0" {
                      description
                        "../BinsCount != 0";
                    }
                    type uint32 {
                      range "1..10000";
                    }
                    description
                      "Width of each bin";
                  }

                  leaf bins-width-tenths {
                    type uint32 {
                      range "0..9";
                    }
                    description
                      "Tenths portion of the bin width";
                  }
                }  // container aggregation

                leaf enable {
                  type empty;
                  description
                    "Enable statistic gathering of the metric";
                }

                leaf buckets-archive {
                  type uint32 {
                    range "1..100";
                  }
                  description
                    "Number of buckets to archive in memory";
                }

                leaf statistic-name {
                  type dt2:Sla-statistic-type-enum;
                  description
                    "The type of statistic to measure";
                }
              }  // list statistic
            }  // container statistics

            container schedule {
              presence
                "Indicates a schedule node is configured.";
              description
                "Schedule to use for probes within an
               operation";
              leaf probe-interval {
                type uint32 {
                  range "1..90";
                }
                description
                  "Interval between probes.  This must be
                 specified if, and only if, ProbeIntervalUnit
                 is not 'Week' or 'Day'.";
              }

              leaf probe-interval-day {
                type dt2:Sla-probe-interval-day-enum;
                description
                  "Day of week on which to schedule probes.
                 This must be specified if, and only if,
                 ProbeIntervalUnit is 'Week'.";
              }

              leaf probe-interval-unit {
                type dt2:Sla-probe-interval-units-enum;
                mandatory true;
                description
                  "Time unit associated with the ProbeInterval.
                 The value must not be 'Once'.  If 'Week' or
                 'Day' is specified, probes are scheduled
                 weekly or daily respectively.";
              }

              leaf start-time-hour {
                type uint32 {
                  range "0..23";
                }
                description
                  "Time after midnight (in UTC) to send the
                 first packet each day.";
              }

              leaf start-time-minute {
                type uint32 {
                  range "0..59";
                }
                description
                  "Time after midnight (in UTC) to send the
                 first packet each day. This must be
                 specified if, and only if, StartTimeHour is
                 specified.";
              }

              leaf start-time-second {
                type uint32 {
                  range "0..59";
                }
                description
                  "Time after midnight (in UTC) to send the
                 first packet each day. This must only be
                 specified if StartTimeHour is specified, and
                 must not be specified if ProbeIntervalUnit
                 is 'Week' or 'Day'.";
              }

              leaf probe-duration {
                type uint32 {
                  range "1..3600";
                }
                description
                  "Duration of each probe.  This must be
                 specified if, and only if, ProbeDurationUnit
                 is specified.";
              }

              leaf probe-duration-unit {
                type dt2:Sla-probe-duration-units-enum;
                description
                  "Time unit associated with the ProbeDuration.
                 The value must not be 'Once'.";
              }
            }  // container schedule

            container probe {
              description
                "Probe configuration for the SLA profile";
              container send {
                presence
                  "Indicates a send node is configured.";
                description
                  "Schedule to use for packets within a burst.
                 The default value is to send a single packet
                 once.";
                leaf burst-interval {
                  type uint32 {
                    range "1..3600";
                  }
                  description
                    "Interval between bursts.  This must be
                   specified if, and only if, the SendType is
                   'Burst' and the 'BurstIntervalUnit' is not
                   'Once'.";
                }

                leaf burst-interval-unit {
                  type dt2:Sla-burst-interval-units-enum;
                  description
                    "Time unit associated with the BurstInterval
                   .  This must be specified if, and only if,
                   SendType is 'Burst'.";
                }

                leaf packet-interval {
                  type uint32 {
                    range "1..30000";
                  }
                  description
                    "Interval between packets.  This must be
                   specified if, and only if,
                   PacketIntervalUnit is not 'Once'.";
                }

                leaf packet-interval-unit {
                  type dt2:Sla-packet-interval-units-enum;
                  mandatory true;
                  description
                    "Time unit associated with the
                   PacketInterval";
                }

                leaf packet-count {
                  type uint32 {
                    range "2..1200";
                  }
                  description
                    "The number of packets in each burst.  This
                   must be specified if, and only if, the
                   SendType is 'Burst'.";
                }

                leaf send-type {
                  type dt2:Sla-send;
                  mandatory true;
                  description
                    "The packet distribution: single packets or
                   bursts of packets.  If 'Burst' is specified
                   , PacketCount and BurstInterval must be
                   specified.";
                }
              }  // container send

              container packet-size-and-padding {
                presence
                  "Indicates a packet-size-and-padding node is configured.";
                description
                  "Minimum size to pad outgoing packet to";
                leaf size {
                  type uint32 {
                    range "1..9000";
                  }
                  mandatory true;
                  description
                    "Minimum size to pad outgoing packet to";
                }

                leaf padding-type {
                  type dt2:Sla-padding-pattern;
                  description
                    "Type of padding to be used for the packet";
                }

                leaf padding-value {
                  type xr:Hex-integer;
                  description
                    "Pattern to be used for hex padding. This
                   can be specified if, and only if, the
                   PaddingType is 'Hex'.";
                }
              }  // container packet-size-and-padding

              leaf priority {
                type uint32 {
                  range "0..7";
                }
                description
                  "Priority class to assign to outgoing SLA
                 packets";
              }

              leaf synthetic-loss-calculation-packets {
                type uint32 {
                  range "10..12096000";
                }
                description
                  "Number of packets to use in each FLR
                 calculation";
              }
            }  // container probe

            leaf packet-type {
              type string;
              mandatory true;
              description
                "The possible packet types are cfm-loopback,
               cfm-delay-measurement,
               cfm-delay-measurement-version-0,
               cfm-loss-measurement and
               cfm-synthetic-loss-measurement";
            }

            leaf profile-name {
              type xr:Cisco-ios-xr-string;
              description "Profile name";
            }
          }  // list profile
        }  // container profiles
      }  // container ethernet
    }

    augment /a1:interface-configurations/a1:interface-configuration/a2:ethernet-features {
      description
        "This augment extends the configuration data of
       'Cisco-IOS-XR-l2-eth-infra-cfg'";
      container cfm {
        description
          "CFM interface configuration";
        container domains {
          description
            "Domain-specific interface configuration";
          list domain {
            key "domain";
            description
              "Configuration for a particular Maintenance
             Domain";
            container mep {
              description
                "MEP Configuration";
              container sla-profile-target-mep-ids {
                description
                  "SLA specific configuration";
                list sla-profile-target-mep-id {
                  key "profile target-mep-id";
                  description
                    "Configuration for a particular SLA
                   operation";
                  leaf profile {
                    type xr:Cisco-ios-xr-string;
                    description
                      "SLA profile name";
                  }

                  leaf target-mep-id {
                    type dt1:Cfm-mep-id;
                    description
                      "Target MEP-ID";
                  }
                }  // list sla-profile-target-mep-id

                list sla-profile-target-mac-address {
                  key "profile target-mac-address";
                  description
                    "Configuration for a particular SLA
                   operation";
                  leaf profile {
                    type xr:Cisco-ios-xr-string;
                    description
                      "SLA profile name";
                  }

                  leaf target-mac-address {
                    type yang:mac-address;
                    description
                      "Target MAC address";
                  }
                }  // list sla-profile-target-mac-address
              }  // container sla-profile-target-mep-ids

              container mep-properties {
                presence
                  "Indicates a mep-properties node is configured.";
                description
                  "Properties for this MEP";
                leaf service {
                  type string {
                    length "1..127";
                  }
                  mandatory true;
                  description
                    "Service (Maintenance Association)";
                }

                leaf mep-id {
                  type dt1:Cfm-mep-id;
                  mandatory true;
                  description "MEP ID";
                }
              }  // container mep-properties

              container loss-measurement-counters {
                presence
                  "Indicates a loss-measurement-counters node is configured.";
                description
                  "Loss-measurement specific configuration";
                leaf cfg-type {
                  type Cfm-lm-counters-cfg;
                  mandatory true;
                  description
                    "Aggregate, List, or Range";
                }

                leaf cos0 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - start of
                   range or list item";
                }

                leaf cos1 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - end of
                   range or list item";
                }

                leaf cos2 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - list item";
                }

                leaf cos3 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - list item";
                }

                leaf cos4 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - list item";
                }

                leaf cos5 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - list item";
                }

                leaf cos6 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - list item";
                }

                leaf cos7 {
                  type dt1:Cfm-cos-bits;
                  description
                    "CoS bits for per-CoS counters - list item";
                }
              }  // container loss-measurement-counters

              leaf llf {
                type empty;
                description
                  "Enable interface TX-disable on remote fault
                 detection for this MEP";
              }

              leaf cos {
                type dt1:Cfm-cos-bits;
                description
                  "The Class of Service bits for this MEP";
              }
            }  // container mep

            leaf domain {
              type string {
                length "1..127";
              }
              description
                "Maintenance Domain";
            }
          }  // list domain
        }  // container domains

        container ais-up {
          description
            "Interface specific AIS configuration";
          container transmission {
            presence "enable transmission";
            description
              "AIS transmission configuration";
            leaf ais-interval {
              type dt1:Cfm-ais-interval;
              description "AIS Interval";
            }

            leaf cos {
              type dt1:Cfm-cos-bits;
              description
                "Class of Service bits";
            }
          }  // container transmission
        }  // container ais-up

        container bandwidth-notifications {
          description
            "Bandwidth Notification configuration";
          leaf wait-to-restore {
            type dt1:Cfm-bnm-wtr;
            default "10";
            description
              "Wait-to-restore time (in seconds)";
          }

          leaf log-changes {
            type empty;
            description
              "Enable logging of bandwidth changes";
          }

          leaf hold-off {
            type dt1:Cfm-bnm-hold-off;
            default "0";
            description
              "Hold-off time (in seconds)";
          }

          leaf loss-threshold {
            type dt1:Cfm-bnm-loss-threshold;
            default "3";
            description
              "Loss Threshold (in number of BNMs)";
          }
        }  // container bandwidth-notifications
      }  // container cfm
    }

    augment /a2:ethernet-features {
      description
        "This augment extends the configuration data of
       'Cisco-IOS-XR-l2-eth-infra-cfg'";
      container cfm {
        description
          "CFM global configuration";
        container traceroute-cache {
          description
            "Traceroute Cache Configuration";
          leaf hold-time {
            type uint32 {
              range "1..525600";
            }
            default "100";
            description
              "Hold Time in minutes";
          }

          leaf cache-size {
            type uint32 {
              range "1..4294967295";
            }
            default "100";
            description
              "Cache Size limit (number of replies)";
          }
        }  // container traceroute-cache

        container domains {
          description
            "Domain-specific global configuration";
          list domain {
            key "domain";
            description
              "Configuration for a particular Maintenance
             Domain";
            container services {
              description
                "Service-specific global configuration";
              list service {
                key "service";
                description
                  "Configuration for a particular Service
                 (Maintenance Association)";
                container efd2 {
                  presence
                    "Indicates a efd2 node is configured.";
                  description
                    "Enable EFD to bring down ports when MEPs
                   detect errors";
                  leaf enable {
                    type empty;
                    mandatory true;
                    description "Enable EFD";
                  }

                  leaf protection-switching-enable {
                    type empty;
                    description
                      "Enable protection switching notifications";
                  }
                }  // container efd2

                container continuity-check-interval {
                  presence
                    "Indicates a continuity-check-interval node is configured.";
                  description
                    "Continuity Check Interval and Loss
                   Threshold.  Configuring the interval
                   enables Continuity Check.";
                  leaf ccm-interval {
                    type dt1:Cfm-ccm-interval;
                    mandatory true;
                    description
                      "CCM Interval";
                  }

                  leaf loss-threshold {
                    type uint32 {
                      range "2..255";
                    }
                    description
                      "Loss Threshold (default 3)";
                  }
                }  // container continuity-check-interval

                container mip-auto-creation {
                  presence
                    "Indicates a mip-auto-creation node is configured.";
                  description
                    "MIP Auto-creation Policy";
                  leaf mip-policy {
                    type Cfm-mip-policy;
                    mandatory true;
                    description
                      "MIP Auto-creation Policy";
                  }

                  leaf ccm-learning-enable {
                    type empty;
                    description
                      "Enable CCM Learning at MIPs in this
                     service";
                  }
                }  // container mip-auto-creation

                container ais {
                  description
                    "Service specific AIS configuration";
                  container transmission {
                    presence
                      "enable transmission";
                    description
                      "AIS transmission configuration";
                    leaf ais-interval {
                      type dt1:Cfm-ais-interval;
                      description
                        "AIS Interval";
                    }

                    leaf cos {
                      type dt1:Cfm-cos-bits;
                      description
                        "Class of Service bits";
                    }
                  }  // container transmission
                }  // container ais

                container cross-check {
                  description
                    "Cross-check configuration";
                  container cross-check-meps {
                    description
                      "Cross-check MEPs";
                    list cross-check-mep {
                      key "mep-id";
                      description
                        "MEP ID and optional MAC Address for
                       Cross-check";
                      leaf mep-id {
                        type dt1:Cfm-mep-id;
                        description "MEP ID";
                      }

                      leaf enable-mac-address {
                        type empty;
                        description
                          "MAC Address is specified";
                      }

                      leaf mac-address {
                        type yang:mac-address;
                        description
                          "MAC Address";
                      }
                    }  // list cross-check-mep
                  }  // container cross-check-meps

                  leaf auto {
                    type empty;
                    description
                      "Enable automatic MEP cross-check";
                  }
                }  // container cross-check

                container service-properties {
                  presence
                    "Indicates a service-properties node is configured.";
                  description
                    "Fundamental properties of the service
                   (maintenance association)";
                  leaf service-type {
                    type Cfm-service;
                    mandatory true;
                    description
                      "Type of Service";
                  }

                  leaf group-name {
                    type string;
                    description
                      "Bridge Group or Cross-connect Group, if
                     Service Type is BridgeDomain or
                     CrossConnect";
                  }

                  leaf switching-name {
                    type string;
                    description
                      "Bridge Domain or Cross-connect name, if
                     Service Type is BridgeDomain or
                     CrossConnect";
                  }

                  leaf ce-id {
                    type uint32 {
                      range "1..16384";
                    }
                    description
                      "Local Customer Edge Identifier";
                  }

                  leaf remote-ce-id {
                    type uint32 {
                      range "1..16384";
                    }
                    description
                      "Remote Customer Edge Identifier";
                  }

                  leaf evi {
                    type uint32 {
                      range "1..65534";
                    }
                    description "EVPN ID";
                  }

                  leaf short-ma-name-format {
                    type Cfm-short-ma-name-format;
                    description
                      "Short MA Name Format";
                  }

                  leaf short-ma-name-string {
                    type xr:Cisco-ios-xr-string {
                      length "1..45";
                    }
                    description
                      "String Short MA Name, if format is String";
                  }

                  leaf short-ma-name-number {
                    type uint32 {
                      range "0..65535";
                    }
                    description
                      "Numeric Short MA Name, if format is VlanID
                     or Number";
                  }

                  leaf short-ma-name-oui {
                    type uint32 {
                      range "0..16777215";
                    }
                    description
                      "VPN OUI, if Short MA Name format is VPN_ID";
                  }

                  leaf short-ma-name-vpn-index {
                    type uint32;
                    description
                      "VPN Index, if Short MA Name format is
                     VPN_ID";
                  }

                  leaf short-ma-name-icc {
                    type xr:Cisco-ios-xr-string {
                      length "1..6";
                    }
                    description
                      "ITU Carrier Code (ICC), if format is
                     ICCBased";
                  }

                  leaf short-ma-name-umc {
                    type xr:Cisco-ios-xr-string {
                      length "1..12";
                    }
                    description
                      "Unique MEG ID Code (UMC), if format is
                     ICCBased";
                  }
                }  // container service-properties

                leaf maximum-meps {
                  type uint32 {
                    range "2..8190";
                  }
                  default "100";
                  description
                    "Limit on the number of MEPs in the service";
                }

                leaf log-cross-check-errors {
                  type empty;
                  description
                    "Log Cross-check Errors detected for peer
                   MEPs";
                }

                leaf continuity-check-archive-hold-time {
                  type uint32 {
                    range "1..65535";
                  }
                  default "100";
                  description
                    "How long to store information for peer MEPs
                   that have timed out";
                }

                leaf tags {
                  type uint32 {
                    range "1";
                  }
                  description
                    "The number of tags to use when sending CFM
                   packets from up MEPs in this Service";
                }

                leaf log-continuity-check-state-changes {
                  type empty;
                  description
                    "Log peer MEPs state changes";
                }

                leaf log-efd {
                  type empty;
                  description
                    "Enable logging";
                }

                leaf continuity-check-auto-traceroute {
                  type empty;
                  description
                    "Automatically trigger a traceroute when a
                   peer MEP times out";
                }

                leaf log-continuity-check-errors {
                  type empty;
                  description
                    "Log CCM Errors detected for peer MEPs";
                }

                leaf log-ais {
                  type empty;
                  description
                    "Log receipt of AIS and LCK messages";
                }

                leaf service {
                  type string {
                    length "1..127";
                  }
                  description
                    "Service (Maintenance Association)";
                }
              }  // list service
            }  // container services

            container domain-properties {
              description
                "Fundamental properties of the domain";
              leaf level {
                type dt1:Cfm-level;
                description
                  "Maintenance Domain Level";
              }

              leaf mdid-format {
                type Cfm-mdid-format;
                description
                  "Maintenance Domain ID Format";
              }

              leaf mdid-mac-address {
                when
                  "../mdid-format = 'mac-address'" {
                  description
                    "../MDIDFormat = MACAddress";
                }
                type yang:mac-address;
                description
                  "MAC Address, if MDID Format is MACAddress";
              }

              leaf mdid-number {
                when
                  "../mdid-format = 'mac-address'" {
                  description
                    "../MDIDFormat = MACAddress";
                }
                type uint32 {
                  range "0..65535";
                }
                description
                  "Unsigned 16-bit Interger, if MDID Format is
                 MACAddress";
              }

              leaf mdid-string {
                when
                  "../mdid-format = 'dns-like' or ../mdid-format = 'string'" {
                  description
                    "../MDIDFormat = DNSLike or ../MDIDFormat =
                   String";
                }
                type string {
                  length "1..43";
                }
                description
                  "String MDID, if MDID format is String or
                 DNSLike";
              }
            }  // container domain-properties

            leaf domain {
              type string {
                length "1..127";
              }
              description
                "Maintenance Domain";
            }
          }  // list domain
        }  // container domains

        leaf nv-satellite-sla-processing-disable {
          type empty;
          description
            "Disable processing of Ethernet SLA packets on
           nV Satellite devices";
        }
      }  // container cfm
    }

    augment /a3:snmp/a3:notification {
      description
        "This augment extends the configuration data of
       'Cisco-IOS-XR-snmp-agent-cfg'";
      container cfm {
        description
          "802.1ag Connectivity Fault Management MIB
         notification configuration";
        leaf enable {
          type empty;
          description
            "Enable 802.1ag Connectivity Fault Management
           MIB notifications";
        }
      }  // container cfm
    }
  }  // module Cisco-IOS-XR-ethernet-cfm-cfg