module cisco-smart-license {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/cisco-smart-license";

    prefix cisco-smart-license;

    import cisco-semver {
      prefix cisco-semver;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import ietf-inet-types {
      prefix inet;
    }

    include cisco-smart-license-errors;

    organization "Cisco Systems, Inc.";

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

    description
      "Smart licensing configuration, RPC, notification and operational data.

     Copyright (c) 2016-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-03-01" {
      description
        "- Added support for conversion status for each product instance in an
         HA configuration
       - Added support for RUM report keys for all closed and unacked reports
       - Added support for RUM ACK status information
       - Added support for information about licenses purchased and installed
         for each device at manufacturing time
       - Added support for information about all licenses that are authorized";
    }

    revision "2020-11-01" {
      description
        "- Added support for policies & usage reporting for 17.4.1
       - Added leaf node authorization return string for online and offline
         authorization code return";
    }

    revision "2019-07-01" {
      description
        "Establish semantic version baseline";
    }

    revision "2017-10-11" {
      description
        "Initial Revision to allow register/de-register, enable/disable,
       get register status, receive notifications, get
        license usage and other state information.";
      reference
        "https://software.cisco.com/";

    }

    cisco-semver:module-version "1.0.0";

    typedef fail-message-type {
      type string {
        length "0..255";
      }
      description
        "If an operation failed then this the message that
        can be displayed for the user. This is not a parsable string.";
    }

    typedef notif-register-failure-enum {
      type enumeration {
        enum "general-failure" {
          value 0;
          description "General failure.";
        }
        enum "already-registered-failure" {
          value 1;
          description
            "This smart licensing instance is already registered.";
        }
        enum "de-register-failure" {
          value 2;
          description
            "The de-register failed because this instance is not registered.";
        }
      }
      description
        "Registration failure reasons. In all cases
       notif-failure-data-group.message will contain a more
       detailed failure message.";
    }

    typedef registration-state-enum {
      type enumeration {
        enum "reg-state-not-registered" {
          value 0;
          description
            "This smart licensing instance is not registered.";
        }
        enum "reg-state-complete" {
          value 1;
          description
            "Registration was successful and this smart licensing
           instance is registered.";
        }
        enum "reg-state-in-progress" {
          value 2;
          description
            "Registration is in progress.";
        }
        enum "reg-state-retry" {
          value 3;
          description
            "The initial registration attempt failed but
           a retry is in progress.";
        }
        enum "reg-state-failed" {
          value 4;
          description "Registration failed.";
        }
      }
      description
        "The smart licensing registration state.";
    }

    typedef authorization-state-enum {
      type enumeration {
        enum "auth-state-none" {
          value 0;
          description
            "No licenses are in use so there is no authorization
           state to report.";
        }
        enum "auth-state-eval" {
          value 1;
          description
            "Evaluation period is in use and is counting down.";
        }
        enum "auth-state-eval-expired" {
          value 2;
          description
            "Evaluation period in use but it has expired.";
        }
        enum "auth-state-authorized" {
          value 3;
          description
            "All license usage is authorized and within terms
           of the customer's contract.";
        }
        enum
          "auth-state-authorized-reservation" {
          value 4;
          description
            "All license usage is authorized because a
           reservation authorization code is installed.";
        }
        enum "auth-state-out-of-compliance" {
          value 5;
          description
            "License usage is out of compliance with the
           terms of the contract. Either too many licenses are in
           use or licenses that were not purchased are in use.";
        }
        enum
          "auth-state-authorization-expired" {
          value 6;
          description
            "The authorization period has expired because this
           product instance has not communicated with the
           SSM or satellite in over 90 days.";
        }
      }
      description
        "The smart licensing authorization state.";
    }

    typedef utility-reporting-type-enum {
      type enumeration {
        enum "utility-reporting-type-none" {
          value 0;
          description
            "The system is not reporting utility usage data.";
        }
        enum
          "utility-reporting-type-subscription" {
          value 1;
          description
            "The system is reporting utility usage data because it has
           received subscription information from either the SSM or
           satellite.";
        }
        enum
          "utility-reporting-type-certificate" {
          value 2;
          description
            "The system is reporting utility usage data because it has
           received a utility certificate from a Third Party
           Billing Platform.";
        }
      }
      description
        "What has triggered the system to start reporting utility usage.";
    }

    typedef transport-type-enum {
      type enumeration {
        enum "transport-type-callhome" {
          value 0;
          description
            "Smart Licensing is using callhome for communications.";
        }
        enum "transport-type-smart" {
          value 1;
          description
            "Smart licensing is using the smart transport for
           communications.";
        }
        enum "transport-type-cslu" {
          value 2;
          description
            "Smart licensing is using the Cisco Smart License Utility
           cslu transport for communications.";
        }
        enum "transport-type-off" {
          value 3;
          description
            "Smart licensing is using the Offline method for communications.";
        }
        enum "transport-type-automatic" {
          value 4;
          description
            "Smart licensing will automatically select
           transport for communications.";
        }
      }
      description
        "The type of transport in use by smart licensing.";
    }

    typedef enforcement-mode-enum {
      type enumeration {
        enum "enforcement-waiting" {
          value 0;
          description
            "The initial state after an entitlement request while we are waiting
           the Authorization request response. In this mode the device will
           have established communications with Cisco and successfully
           registered with the Cisco Licensing cloud.";
        }
        enum "enforcement-in-compliance" {
          value 1;
          description
            "Cisco Smart Software Manager (CSSM) has responded that
           the entitlement requested is in compliance.";
        }
        enum "enforcement-out-of-compliance" {
          value 2;
          description
            "Cisco Smart Software Manager (CSSM) has responded that
           the entitlement requested is out of compliance.
           either too many licenses /entitlements are in use or the license
           has not been purchased";
        }
        enum "enforcement-overage" {
          value 3;
          description
            "more licenses are in use than were purchased but the customer
            is still within the terms of their contract";
        }
        enum "enforcement-evaluation" {
          value 4;
          description
            "The evaluation period is in use.
           It will remain in use until the following
           two messages have been received by the product from the
           Cisco Smart Software Manager (CSSM):
            Successful response to a registration request,
            successful response to an entitlement authorization request";
        }
        enum
          "enforcement-evaluation-expired" {
          value 5;
          description
            "The evaluation period has expired";
        }
        enum
          "enforcement-authorization-expired" {
          value 6;
          description
            "Authorization period has expired. This will occur if the product
           has not been able to communicate with Cisco or a satellite
           for an extended period of time, usually 90 days.";
        }
        enum
          "enforcement-reservation-in-compliance" {
          value 7;
          description
            "The entitlement requested is in compliance because
           a reservation authorization code is installed and the product
           is in Permanent License Reservation mode.";
        }
        enum "enforcement-invalid-tag" {
          value 8;
          description
            "The entitlement tag is invalid.
           The CSSM does not recognize the entitlement tag
           because it is not in the database. This usually only occurs
           during testing.";
        }
        enum "enforcement-disabled" {
          value 9;
          description
            "Smart licensing has been disabled. The feature using this license
           should be disabled.";
        }
      }
      description
        "For an entitlement tag (license) that is in use this enumeration
        tells us how the license is being enforced.";
    }

    typedef policy-types-enum {
      type enumeration {
        enum "policy-type-cisco-invalid" {
          value 0;
          description "The invalid policy.";
        }
        enum "policy-type-cisco-default" {
          value 1;
          description
            "The cisco default policy.";
        }
        enum "policy-type-platform-default" {
          value 2;
          description
            "The default policy for this platform.";
        }
        enum "policy-type-factory-installed" {
          value 3;
          description
            "The default policy installed in factory.";
        }
        enum "policy-type-custom" {
          value 4;
          description
            "The policy configure by user.";
        }
        enum "policy-type-plr" {
          value 5;
          description
            "Special policy type for PLR.";
        }
        enum "policy-type-fla" {
          value 6;
          description
            "Special policy type for FLA.";
        }
        enum "policy-type-controller" {
          value 7;
          description
            "The policy type for controller.";
        }
        enum "policy-type-merged" {
          value 8;
          description
            "Merged policy - policy is merged from multiple source.";
        }
      }
      description
        "The types of policies that can be in use.";
    }

    typedef conversion-status-enum {
      type enumeration {
        enum
          "conversion-status-not-supported" {
          value 0;
          description
            "The license conversion is not supported on this
           product instance.";
        }
        enum "conversion-status-not-started" {
          value 1;
          description
            "The license conversion has not started yet";
        }
        enum "conversion-status-started" {
          value 2;
          description
            "Conversion has started. The conversion data has been sent
           to Cisco. A reply confirming receipt is expected.";
        }
        enum "Conversion-status-success" {
          value 3;
          description "Conversion Success";
        }
        enum
          "conversion-status-already-converted" {
          value 4;
          description
            "Conversion data was received by Cisco. Already converted";
        }
        enum "conversion-status-failed" {
          value 5;
          description
            "Conversion has failed.";
        }
        enum "conversion-status-polling" {
          value 6;
          description
            "Conversion polling the satellite for a response.";
        }
      }
      description
        "Status of a license conversion.";
    }

    typedef rum-report-state-enum {
      type enumeration {
        enum "rum-report-state-invalid" {
          value 0;
          description
            "Rum report is newly created and measurement
           and metadata can be added.";
        }
        enum "rum-report-state-open" {
          value 1;
          description
            "Report is currently open. New measurements may
           still be added.";
        }
        enum "rum-report-state-closed" {
          value 2;
          description
            "Report is closed. New measurements will not be added.
           Report has not been requested from the data model.";
        }
        enum "rum-report-state-pending" {
          value 3;
          description
            "Report was sent to a remote end point but was not
           acknowledged yet.";
        }
        enum
          "rum-report-state-unacknowledged" {
          value 4;
          description
            "Report has been requested from the data model at least once
           but not acknowledged.";
        }
        enum "rum-report-state-acknowledged" {
          value 5;
          description
            "Report was sent to remote end and acknowledged.";
        }
      }
      description
        "The state of a ISO19770-4 Resource Utilization Measurement
       (RUM) report in the data model. This state is
       used by the Cisco Smart License Utility (CSLU) so it can
       easily determine which RUM
       reports it has requested in the past and which are new reports
       that it should request.";
    }

    typedef license-enforcement-type-enum {
      type enumeration {
        enum
          "license-enforcement-type-invalid" {
          value 0;
          description
            "License type is invalid.";
        }
        enum
          "license-enforcement-type-unenforced" {
          value 1;
          description
            "License type is unenforced.";
        }
        enum
          "license-enforcement-type-enforced" {
          value 2;
          description
            "License type is enforced.";
        }
        enum
          "license-enforcement-type-export" {
          value 3;
          description
            "License type is export restricted.";
        }
      }
      description
        "The license (entitlement tag) type.";
    }

    typedef license-term-type-enum {
      type enumeration {
        enum "license-term-type-none" {
          value 0;
          description
            "License term type is none.";
        }
        enum "license-term-type-perpetual" {
          value 1;
          description
            "License term type is perpetual.";
        }
        enum "license-term-type-term" {
          value 2;
          description
            "License term type is term.";
        }
        enum
          "license-term-type-subscription" {
          value 3;
          description
            "License term type is subscription.";
        }
      }
      description
        "The license (entitlement tag) term type.";
    }

    typedef license-auth-type-enum {
      type enumeration {
        enum "authorization-type-none" {
          value 0;
          description
            "Authorization code is not installed";
        }
        enum "authorization-type-auth-code" {
          value 1;
          description
            "Smart license authorization code";
        }
        enum "authorization-type-slr" {
          value 2;
          description
            "Specific License Reservation authorization code";
        }
        enum "authorization-type-plr" {
          value 3;
          description
            "Permanent License Reservation
           authorization code";
        }
        enum "authorization-type-fla" {
          value 4;
          description
            "Federal License Authorization code";
        }
        enum "authorization-type-pak" {
          value 5;
          description
            "This is an authorization that was fulfilled from a
           Product Activation Key (PAK) and was previously installed
           using Cisco Software Licensing (CSL).";
        }
      }
      description
        "The types of authorizations that may be installed";
    }

    grouping registration-fail-info {
      description
        "Failure info for a registration failure.";
      leaf fail-time {
        type yang:date-and-time;
        description
          "Time the registration failed.";
      }

      leaf fail-message {
        type fail-message-type;
        description
          "Failure message that can be displayed for the user.
         This is not a parsable message.";
      }
    }  // grouping registration-fail-info

    grouping registration-state {
      description
        "The state of the registration for this product instance.";
      leaf registration-state {
        type registration-state-enum;
        description
          "The current registration state.";
      }

      container registration-in-progress {
        when
          "../registration-state = 'reg-state-in-progress'";
        description
          "Registration is in progress.";
        leaf start-time {
          type yang:date-and-time;
          description
            "Time the registration started.";
        }
      }  // container registration-in-progress

      container registration-failed {
        when
          "../registration-state = 'reg-state-failed'";
        description "Registration failed.";
        uses registration-fail-info;
      }  // container registration-failed

      container registration-retry {
        when
          "../registration-state = 'reg-state-retry'";
        description
          "Registration failed and doing a retry.";
        leaf retry-next-time {
          type yang:date-and-time;
          description
            "Time the registration will be retried.";
        }

        uses registration-fail-info;
      }  // container registration-retry

      container registration-complete {
        when
          "../registration-state = 'reg-state-complete'";
        description "Registration success.";
        leaf complete-time {
          type yang:date-and-time;
          description
            "Time the registration was successful.";
        }

        leaf last-renew-time {
          type yang:date-and-time;
          description
            "Time the last registration renewal occurred.
           If empty then no renewal has occurred.";
        }

        leaf next-renew-time {
          type yang:date-and-time;
          description
            "Time the registration will be automatically renewed.";
        }

        leaf expire-time {
          type yang:date-and-time;
          description
            "Time the registration will expire if it is not renewed.";
        }

        leaf last-renew-success {
          type boolean;
          description
            "Was the last renewal attempt successful.";
        }

        leaf fail-message {
          type fail-message-type;
          description
            "If the last renewal failed then this is a failure message that
           can be displayed for the user.
           This is not a parsable string.
           Only present if the last renewal failed";
        }

        leaf smart-account {
          type string {
            length "1..255";
          }
          description
            "The smart account name for this registration.";
        }

        leaf virtual-account {
          type string {
            length "1..255";
          }
          description
            "The virtual account name for this registration.";
        }
      }  // container registration-complete

      leaf export-control-allowed {
        type boolean;
        description
          "Is the device allowed to enable export controlled features.";
      }
    }  // grouping registration-state

    grouping udi {
      description
        "The Smart Licensing UDI definition.
       A UDI will contain one or more of the fields defined.
       While the pid and sn fields are most commonly used
       different product types will use different fields. This UDI
       will be unique for each product instance that is installed.";
      leaf pid {
        type string {
          length "1..255";
        }
        description
          "The Product Identifier. Always combined with sn.";
      }

      leaf sn {
        type string {
          length "1..255";
        }
        description
          "The system serial number. Always combined with pid.";
      }

      leaf vid {
        type string {
          length "1..255";
        }
        description
          "The version identifier. Usually combined with pid & sn.";
      }

      leaf uuid {
        type yang:uuid;
        description
          "A 32 byte hex value generated by the system.
         This will be in proper UUID format 8-4-4-4-12. Often used by VMs
         or other systems that do not have a hardware identifier.";
      }

      leaf suvi {
        type string {
          length "1..255";
        }
        description
          "Free form virtual identifier often used by software
         only devices like software routers or VMs.";
      }

      leaf host-identifier {
        type string {
          length "1..255";
        }
        description
          "Host identifier available on some systems.
         Typically 8 hex digits.";
      }

      leaf mac-address {
        type yang:mac-address;
        description
          "The MAC address of the system. This is usually only used if there
         is nothing else available to be used as an identifier.";
      }
    }  // grouping udi

    grouping authorization-info {
      description
        "Additional authorization state information used by some of
       the authorization states.";
      leaf last-comm-status-success {
        type boolean;
        description
          "Last communication was successful or failed.";
      }

      leaf fail-message {
        type fail-message-type;
        description
          "Failure message if the last communications attempt failed.
         This can be displayed for the user. It is not a parsable string.";
      }

      leaf last-comm-time {
        type yang:date-and-time;
        description
          "Time the last communication attempt happened.";
      }

      leaf next-comm-time {
        type yang:date-and-time;
        description
          "The next time communications will be attempted to the back end.
         This will be zero if the initial communication has not completed.";
      }

      leaf comm-deadline-time {
        type yang:date-and-time;
        description
          "If there are no communications between now and this time
         smart licensing will enter the authorization expired state.
         This may be zero indicating there is no deadline.";
      }
    }  // grouping authorization-info

    grouping evaluation-time-left {
      description
        "Number of seconds of license usage until the evaluation
       period expires.";
      leaf seconds-left {
        type uint64;
        description
          "Number of seconds of license usage until the evaluation
         period expires. Note that this not a hard date and time because
         if no licenses are in use the evaluation period stops
         counting down.";
      }
    }  // grouping evaluation-time-left

    grouping authorization-state {
      description
        "The license authorization state.";
      leaf authorization-state {
        type authorization-state-enum;
        description
          "The current authorization state.";
      }

      container authorization-none {
        when
          "../authorization-state = 'auth-state-none'";
        description
          "No licenses in use. This empty container is not needed but is
         a place holder to show there is no data for this state.";
      }  // container authorization-none

      container authorization-eval {
        when
          "../authorization-state = 'auth-state-eval'";
        description
          "Evaluation period is in use and counting down.
         The evaluation period only counts down when licenses are
         in use.";
        uses evaluation-time-left;
      }  // container authorization-eval

      container authorization-eval-expired {
        when
          "../authorization-state = 'auth-state-eval-expired'";
        description
          "Evaluation period is in use but has expired.";
        leaf expire-time {
          type yang:date-and-time;
          description
            "Time the evaluation period expired.";
        }
      }  // container authorization-eval-expired

      container authorization-authorized {
        when
          "../authorization-state = 'auth-state-authorized'";
        description
          "All license usage is authorized and within terms of the contract.";
        uses authorization-info;
      }  // container authorization-authorized

      container authorization-authorized-reservation {
        when
          "../authorization-state = 'auth-state-authorized-reservation'";
        description
          "All license usage is authorized because a
         reservation authorization code is installed.";
        leaf reservation-time {
          type yang:date-and-time;
          description
            "Time the reservation occurred.";
        }
      }  // container authorization-authorized-reservation

      container authorization-out-of-compliance {
        when
          "../authorization-state = 'auth-state-out-of-compliance'";
        description
          "License usage is out of compliance with the terms of the
         contract because more licenses are in use than were purchased.";
        uses authorization-info;

        leaf ooc-time {
          type yang:date-and-time;
          description
            "Time the product instance entered the out of compliance state.";
        }
      }  // container authorization-out-of-compliance

      container authorization-authorization-expired {
        when
          "../authorization-state = 'auth-state-authorization-expired'";
        description
          "The authorization period has expired because the product
         instance ahs not communicated with the SSM or satellite in
         over 90 days.";
        uses authorization-info;
      }  // container authorization-authorization-expired
    }  // grouping authorization-state

    grouping customer-info {
      description
        "Customer name and address information.";
      leaf id {
        type string {
          length "1..250";
        }
        description
          "The cisco issued customer id which will be included
         in the utility usage (RUM) report.";
      }

      leaf name {
        type string {
          length "1..250";
        }
        description
          "The customer company name which will be included
         in the utility usage (RUM) report.";
      }

      leaf street {
        type string {
          length "1..250";
        }
        description
          "The customer company street address which will be included
         in the utility usage (RUM) report.";
      }

      leaf city {
        type string {
          length "1..250";
        }
        description
          "The customer company city which will be included
         in the utility usage (RUM) report.";
      }

      leaf state {
        type string {
          length "1..250";
        }
        description
          "The customer company state which will be included
         in the utility usage (RUM) report.";
        reference
          "ISO3166 standard for state codes.";

      }

      leaf country {
        type string {
          length "1..250";
        }
        description
          "The customer company country which will be included
         in the utility usage (RUM) report.";
        reference
          "ISO3166 standard for country codes.";

      }

      leaf postal-code {
        type string {
          length "1..250";
        }
        description
          "The customer location specific postal code
         which will be included in the utility usage (RUM) report.";
      }
    }  // grouping customer-info

    grouping utility-state {
      description
        "State of utility reporting in smart licensing.";
      leaf enabled {
        type boolean;
        description
          "Utility reporting is enabled. The system still
         needs a utility certificate registration or a subscription
         to begin reporting actual utility data.";
      }

      leaf reporting {
        type utility-reporting-type-enum;
        description
          "Is the system reporting utility data. If so then what triggered
         it to start reporting. If this is utility-reporting-none then all
         of the times below will be zero.";
      }

      container reporting-times {
        when
          "../reporting != 'utility-reporting-none'";
        description
          "If the product instance is reporting utility data this will
         contain various timing information about that reporting.";
        leaf last-report-time {
          type yang:date-and-time;
          description
            "Time the last report was sent.";
        }

        leaf last-report-success {
          type boolean;
          description
            "Was the last report successfully sent?";
        }

        leaf fail-message {
          type fail-message-type;
          description
            "Failure message if the last report send failed.";
        }

        leaf next-report-time {
          type yang:date-and-time;
          description
            "Time the next report is scheduled to be sent.";
        }
      }  // container reporting-times

      container customer-info {
        when
          "../reporting != 'utility-reporting-none'";
        description
          "Customer address information that will be sent
         in the utility usage reports.";
        uses customer-info;
      }  // container customer-info
    }  // grouping utility-state

    grouping transport-state {
      description
        "Transport settings. Smart licensing uses the transport to
       send messages to the CSSM, satellite or
       Third Party Billing Platform.";
      leaf transport-type {
        type transport-type-enum;
        description
          "Type of communications transport smart licensing is using.";
      }

      container url-settings {
        when
          "../transport-type = 'transport-type-smart'";
        description
          "URLs in use if the transport type is smart.";
        leaf url-registration {
          type inet:uri;
          description
            "The URL used for registration, authorization and any
           other messages not related to utility.";
        }

        leaf url-utility {
          type inet:uri;
          description
            "The URL used for utility reporting. url-utility and
           url-registration may be the same or different. If a satellite
           is in use then they will probably be the same.";
        }
      }  // container url-settings
    }  // grouping transport-state

    grouping privacy-info {
      description
        "Will smart licensing send the host name in any outgoing messages.";
      leaf hostname {
        type boolean;
        description
          "If true then the hostname will not be sent in
         any messages.";
      }

      leaf version {
        type boolean;
        description
          "If true then the smart licensing version will not be sent in
         any messages.";
      }
    }  // grouping privacy-info

    grouping eval-period-state {
      description
        "State of the evaluation period. In use or not and time left.";
      leaf eval-in-use {
        type boolean;
        description
          "Is the evaluation period currently in use and counting down.";
      }

      leaf eval-expired {
        type boolean;
        description
          "Has the evaluation period expired.";
      }

      container eval-period-left {
        when "../eval-expired = 'false'";
        description
          "If the evaluation period is not expired this is the number
         of seconds left in the period.";
        leaf time-left {
          type uint32;
          description
            "Number of seconds of license usage until the evaluation
           period expires.";
        }
      }  // container eval-period-left

      container eval-expire-time {
        when "../eval-expired = 'true'";
        description
          "If the evaluation period has expired then this is the
         time of the expiration.";
        leaf expire-time {
          type yang:date-and-time;
          description
            "Date and time the evaluation period expired.";
        }
      }  // container eval-expire-time
    }  // grouping eval-period-state

    grouping license-usage {
      description
        "State of usage for a single entitlement tag (license).";
      leaf entitlement-tag {
        type string;
        description
          "The ISO 19770 entitlement tag used to define this license.";
      }

      leaf short-name {
        type string;
        description
          "The human readable license name from the entitlement tag.";
      }

      leaf license-name {
        type string;
        description
          "The license name that can be seen in the CSSM portal or on
         the satellite.
         This is only available after the product has registered.";
      }

      leaf description {
        type string;
        description
          "The long description of this license.
         This is only available after the product has registered.";
      }

      leaf count {
        type uint32;
        description
          "The in-use count of this license. Note that licensing only reports
         usage for licenses that are in use (count of 1 or greater).";
      }

      leaf enforcement-mode {
        type enforcement-mode-enum;
        description
          "The current enforcement mode of this license.";
      }

      leaf post-paid {
        type boolean;
        description
          "If true then this entitlement is being reported in a post paid mode
         with utility usage reports. Otherwise it will be reported in
         the regular prepaid mode.";
      }

      leaf subscription-id {
        type string;
        description
          "If this entitlement tag is being reported in the post paid
         utility usage mode and there is a subscription id in the customer's
         virtual account this will be that subscription id.";
      }
    }  // grouping license-usage

    grouping notif-failure-data-group {
      description
        "Describes why a register operation failed.";
      leaf reason {
        type notif-register-failure-enum;
        description
          "Why did the operation fail.";
      }

      leaf message {
        type fail-message-type;
        description
          "A message describing the details of the failure.";
      }
    }  // grouping notif-failure-data-group

    grouping customer-tags-grouping {
      description
        "Customer defined fields in usage reporting.";
      leaf tag1 {
        type string {
          length "1..127";
        }
        description
          "Customer defined tag field one";
      }

      leaf tag2 {
        type string {
          length "1..127";
        }
        description
          "Customer defined tag field two";
      }

      leaf tag3 {
        type string {
          length "1..127";
        }
        description
          "Customer defined tag field three";
      }

      leaf tag4 {
        type string {
          length "1..127";
        }
        description
          "Customer defined tag field four";
      }
    }  // grouping customer-tags-grouping

    grouping policy-attributes-grouping {
      description "Policy attributes";
      leaf reporting-first-time {
        type uint32;
        description
          "Number of days before the first usage report is required.";
      }

      leaf reporting-ongoing {
        type uint32;
        description
          "Number of days after the first usage report that subsequent
         usage reports are required.";
      }

      leaf reporting-macd {
        type uint32;
        description
          "Number of days after a Move Add Change Delete (MACD)
         operation that a new report is required.";
      }
    }  // grouping policy-attributes-grouping

    grouping policy-state-grouping {
      description
        "Information about which policy is in force and the
       attributes that are set.";
      leaf policy-type {
        type policy-types-enum;
        description
          "Which policy is in force.";
      }

      leaf policy-name {
        type string;
        description
          "The name of the policy if there is one. This comes from
         the 'name' field in the policy XML file.";
      }

      leaf install-time {
        type yang:date-and-time;
        description
          "The time a policy file was installed.";
      }

      leaf ack-required {
        type boolean;
        description
          "Indicates if an ACK is required on the product for each RUM
         report to pervent the syslog from being sent.";
      }

      container policy-enforced {
        description
          "Attributes for an enforced license.";
        uses policy-attributes-grouping;
      }  // container policy-enforced

      container policy-export {
        description
          "Attributes for an export license.";
        uses policy-attributes-grouping;
      }  // container policy-export

      container policy-subscription {
        description
          "Attributes for an subscription license.";
        uses policy-attributes-grouping;
      }  // container policy-subscription

      container policy-perpetual {
        description
          "Attributes for a perpetual license.";
        uses policy-attributes-grouping;
      }  // container policy-perpetual
    }  // grouping policy-state-grouping

    grouping trust-code-state-grouping {
      description
        "Trust code information for a single device (UDI).";
      leaf key_udi {
        type string;
        description
          "This single string key can be used to look up trust code
         information of product instance";
      }

      leaf is-installed {
        type boolean;
        description
          "If true then a trust code is installed.";
      }

      leaf time-installed {
        when "../is-installed = 'true'";
        type yang:date-and-time;
        description
          "The time the trust code was installed.";
      }

      container udi {
        description
          "UDI of the device this trust code state is for.";
        uses udi;
      }  // container udi
    }  // grouping trust-code-state-grouping

    grouping conversion-state-grouping {
      description
        "license conversion status of a single UDI";
      leaf key_udi {
        type string;
        description
          "This single string key can be used to look up conversion
         information of product instance";
      }

      leaf status {
        type conversion-status-enum;
        description "Conversion status";
      }

      leaf status-time {
        type yang:date-and-time;
        description
          "The date and time the status last changed.";
      }

      container udi {
        description "UDI of this status";
        uses udi;
      }  // container udi
    }  // grouping conversion-state-grouping

    grouping rum-report-basic-info-grouping {
      description
        "Basic RUM report info used in multiple groups";
      leaf report-id {
        type uint64;
        description
          "The RUM report id number. id numbers are unique to a UDI";
      }

      container udi {
        description
          "UDI of the Product Instance in a High Availability (HA)
         configuration that the notification applies to.";
        uses udi;
      }  // container udi

      leaf report-start-time {
        type yang:date-and-time;
        description
          "The start time of the first measurement in the RUM report";
      }

      leaf report-end-time {
        type yang:date-and-time;
        description
          "The end time of the last measurement in the RUM report";
      }

      leaf report-state {
        type rum-report-state-enum;
        description
          "The state of a RUM report in the data model. This state is
         used by the CSLU so it can easily determine which RUM
         reports it has requested in the past and which are new
         reports that it should request.";
      }
    }  // grouping rum-report-basic-info-grouping

    grouping rum-report-summary-grouping {
      description
        "Key information used to lookup rum reports in a different
       list.";
      uses rum-report-basic-info-grouping;

      leaf rum-report-key {
        type string;
        description
          "This single string key can be used to look up RUM reports
         in a different list. It will uniquely identify the
         combination of product Instance and report.";
      }
    }  // grouping rum-report-summary-grouping

    grouping rum-ack-state-grouping {
      description
        "Information about the ACKs of RUM reports";
      leaf last-received-time {
        type yang:date-and-time;
        description
          "Time an ACK was last received.";
      }

      leaf next-report-deadline {
        type yang:date-and-time;
        description
          "Time the next ACK is expected to be received.";
      }
    }  // grouping rum-ack-state-grouping

    grouping authorization-confirmation-code-grouping {
      description
        "If an authorization code import overwrote an existing
       authorization code
       then this confirmation code must be returned to the
       Cisco Smart Software Manger (CSSM).";
      container udi {
        description
          "UDI of this confirmation code";
        uses udi;
      }  // container udi

      leaf confirmation-code {
        type string {
          length "1..255";
        }
        description
          "The confirmation code that must be retunred to
         Cisco Smart Software Manger (CSSM)";
      }
    }  // grouping authorization-confirmation-code-grouping

    grouping subscription-info-grouping {
      description
        "If a license term type is license-term-type-subscription
       then this group will contain the subscription information.";
      leaf start-time {
        type yang:date-and-time;
        description
          "Start time for the subscription.";
      }

      leaf end-time {
        type yang:date-and-time;
        description
          "End time for the subscription.";
      }

      leaf subscription-id {
        type string;
        description
          "Subscription id (if available) for this subscription";
      }
    }  // grouping subscription-info-grouping

    grouping license-info-grouping {
      description
        "General entitlement tag (license) information.";
      leaf entitlement-tag {
        type string;
        description
          "The ISO 19770 entitlement tag used to define this license.";
      }

      leaf short-name {
        type string;
        description
          "The human readable license name from the entitlement tag.";
      }

      leaf license-name {
        type string;
        description
          "The license name that can be seen in the
         Cisco Smart Software Manger (CSSM) portal.";
      }

      leaf description {
        type string;
        description
          "The long description of this license.";
      }

      leaf count {
        type uint32;
        description
          "The count of this license.";
      }

      leaf license-enforcement-type {
        type license-enforcement-type-enum;
        description
          "Indicates what enforcement type of license this is.";
      }

      leaf license-term-type {
        type license-term-type-enum;
        description
          "Indicates the type of term used for this licnese.";
      }
    }  // grouping license-info-grouping

    grouping factory-purchase-state-grouping {
      description
        "Information about the licenses the customer purchased for this
       device which are installed at manufacturing time.";
      leaf key_udi {
        type string;
        description
          "This single string key can be used to look up factory purchase
         information of product instance";
      }

      container udi {
        description
          "UDI of this purchase information";
        uses udi;
      }  // container udi

      list basic-license-info {
        key "entitlement-tag";
        description
          "The license information";
        uses license-info-grouping;

        uses subscription-info-grouping;
      }  // list basic-license-info
    }  // grouping factory-purchase-state-grouping

    grouping license-auth-install-info {
      description
        "Authorization install status";
      leaf install-type {
        type license-auth-type-enum;
        description
          "The type of authorization that is installed.";
      }

      leaf install-time {
        type yang:date-and-time;
        description
          "Time the authorization was installed. If blank then
         the install time is not not known.";
      }
    }  // grouping license-auth-install-info

    grouping license-auth-overall-info {
      description
        "Status of any authorizations installed for a Product
       Instance";
      leaf key_udi {
        type string;
        description
          "This single string key can be used to look up trust code
         information of product instance";
      }

      container udi {
        description "UDI of this device";
        uses udi;
      }  // container udi

      list installed-list {
        key "install-type";
        description
          "List of all authorizations installed on this device";
        uses license-auth-install-info;
      }  // list installed-list
    }  // grouping license-auth-overall-info

    grouping license-auth-info {
      description
        "Information about how a single license is authorized.";
      leaf entitlement-tag {
        type string;
        description
          "The ISO 19770-2 entitlement tag used to define
         this license.";
      }

      leaf short-name {
        type string;
        description
          "The human readable license name from the entitlement tag.";
      }

      leaf license-name {
        type string;
        description
          "The license name that can be seen on the
         Cisco Smart Software Manger (CSSM).";
      }

      leaf description {
        type string;
        description
          "The long description of this license.";
      }

      leaf total-count {
        type uint32;
        description
          "The total aggregated count available for this license.";
      }

      leaf license-enforcement-type {
        type license-enforcement-type-enum;
        description
          "Indicates what type of license this is.";
      }
    }  // grouping license-auth-info

    grouping license-auth-status-info {
      description
        "Information about all licenses that are either enforced
       or export restricted and are authorized to be used.";
      list overall-status {
        key "key_udi";
        description
          "List of the authroization code install information for
         each device";
        uses license-auth-overall-info;
      }  // list overall-status

      list authorization-list {
        key "entitlement-tag";
        description
          "List of license and details of how each is authorized.
         If a license is not in this list then it is not authorized.";
        uses license-auth-info;
      }  // list authorization-list
    }  // grouping license-auth-status-info

    rpc register-id-token {
      description
        "Register with an ID token.
       This will begin the registration process. Since the registration
       process will take somewhere between seconds and hours you must get the
       registration-success or registration-fail notifications
       or check the registration status in smart-license:state
       to know the status of the registration.";
      input {
        leaf id-token {
          type string {
            length "1..255";
          }
          description
            "The ID token used to register.";
        }

        leaf force {
          type boolean;
          default "false";
          description
            "Force the registration if set.";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description
            "The return code.
           If smart licensing is not enabled (status:enabled)
           then the error will be error-enum:notenabled.
           On success the return code will be
           error-enum:registrationinprogress.";
        }
      }
    }  // rpc register-id-token

    rpc de-register {
      description
        "De-register. This will immediately de-register the device.";
      output {
        leaf return-code {
          type error-enum;
          description
            "The return code for the de-register process.";
        }
      }
    }  // rpc de-register

    rpc renew-id {
      description
        "Under normal operations smart licensing will automatically renew
       the ID certificates used for regsitration. This command can
       be used if he customer wants to initiate a manual
       registration renewal.";
      output {
        leaf return-code {
          type error-enum;
          description "The return code.";
        }
      }
    }  // rpc renew-id

    rpc renew-auth {
      description
        "Under normal operations smart licensing will automatically renew
       the license authorization every 30 days. This command can
       be used if he customer wants to iinitiate a manual
       renewal.";
      output {
        leaf return-code {
          type error-enum;
          description "The return code.";
        }
      }
    }  // rpc renew-auth

    rpc id-token-trust {
      description
        "Establish trust with the Cisco Smart Software Manager (CSSM)
       using an ID token.
       This will begin the trust establishment process. Since the
       process will take somewhere between seconds and hours you
       must get the trust-success or trust-fail notifications
       or check the trust status in smart-license:state.";
      input {
        leaf id-token {
          type string {
            length "1..255";
          }
          mandatory true;
          description
            "The ID token used to establish trust.";
        }

        leaf all-ha {
          type boolean;
          default "false";
          description
            "If true, perform the operation for all devices
           in an HA configuration. If false, then only establish
           trust for the active device.";
        }

        leaf force {
          type boolean;
          default "false";
          description
            "Force the trust establishment even if the product
           instance has already establish trust with the CSSM.";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description
            "The return code.
           On success the return code will be
           error-enum:registrationinprogress.";
        }
      }
    }  // rpc id-token-trust

    rpc rum-save-usage-all {
      description
        "Save all RUM reports in the file path specified.
       Can be a local path or a network path.
       This could create a file that is a few MB in size.";
      input {
        leaf file-path {
          type string {
            length "1..127";
          }
          mandatory true;
          description
            "The local or network file path to write the RUM
           reports to.";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description "The return code.";
        }
      }
    }  // rpc rum-save-usage-all

    rpc rum-save-usage-unreported {
      description
        "Save unreported RUM reports in the file path specified.
       Can be a local path or a network path";
      input {
        leaf file-path {
          type string {
            length "1..127";
          }
          mandatory true;
          description
            "The local or network file path to write the RUM reports to.";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description "The return code.";
        }
      }
    }  // rpc rum-save-usage-unreported

    rpc rum-save-usage-days {
      description
        "Save all RUM reports in the file path specified.
       Can be a local path or a network path";
      input {
        leaf file-path {
          type string {
            length "1..127";
          }
          mandatory true;
          description
            "The local or network file path to write the RUM reports to.";
        }

        leaf days {
          type uint32;
          description
            "Save RUM reports that include measurements in the
           specified number of days";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description "The return code.";
        }
      }
    }  // rpc rum-save-usage-days

    rpc trust-request-save {
      description
        "Save the trust request in the file path specified.
       Can be a local path or a network path";
      input {
        leaf file-path {
          type string {
            length "1..127";
          }
          mandatory true;
          description
            "The local or network file path to write the trust request to.";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description "The return code.";
        }
      }
    }  // rpc trust-request-save

    rpc authorization-request-online {
      description
        "Queues the request to fetch a node-locked authorization code
       from the CSSM or CSLU. If the Product is not connected to the
       CSLU or CSSM this command will fail. Command is non-blocking and
       will return an immediate failure or an OperationInProgress status.
       Later one of these notifications will be sent to indicate the
       status of the request:
       authorization-code-installed, authorization-code-request-failed ";
      input {
        leaf feature-name {
          type string {
            length "1..255";
          }
          mandatory true;
          description
            "The feature name to get the authorization code for.
           The smart agent will look this up in it's mapping table
           and get the proper entitlement tag for it.";
        }

        leaf local {
          type boolean;
          default "true";
          description
            "Applies to an HA configuration. If true, the authroization
           request will only be for the active device. If False, the
           authorization request will apply to all devices in the
           HA configuration.";
        }

        leaf add {
          type boolean;
          default "true";
          description
            "Applies to an HA configuration. If true, the authroization
           request will add the license to the existing authorization code
           If false, the authorization request will replace the existing
           authorization code with a new authorization code that
           contains only a license for the feature requested.";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description
            "The return code. Under normal operations this will return
           OperationInProgress.";
        }
      }
    }  // rpc authorization-request-online

    rpc authorization-code-return-online {
      description
        "Returns a currently installed authorization code.
       If an entitlement tag is in use and was authorized
       by the current authorization code then the return will fail.
       If the Product is not connected to the CSLU or CSSM this command will fail.
       The authorization code will first be removed from the product.
       Next it will make one attempt to send a message to the CSLU
       or CSSM to return the license to the virtural account.";
      input {
        leaf local {
          type boolean;
          default "true";
          description
            "Applies to an HA configuration. If true, the authroization
           return will only be for the active device.
           If false, the authorization return will apply to all devices in the
           HA configuration.";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description
            "The return code. Under normal operations this will return OperationInProgress";
        }

        leaf authorization-return-string {
          type string;
          description
            "The authorization return string that was sent to the CSSM in the message.";
        }
      }
    }  // rpc authorization-code-return-online

    rpc authorization-code-return-offline {
      description
        "Returns a currently installed authorization code.
       If an entitlement tag is in use and was authorized
       by the current authorization code then the return will fail.
       The authorization code will first be removed from the product.
       Next it write the return code to the file specified.";
      input {
        leaf local {
          type boolean;
          default "true";
          description
            "Applies to an HA configuration. If true, the authroization
           return will only be for the active device.
           If false, the authorization return will apply to all
           devices in the HA configuration.";
        }

        leaf file-path {
          type string {
            length "1..127";
          }
          mandatory true;
          description
            "The local or network file path to write the return code to.
           This is optional. If included the authorization return string
           will be written to the named file. In either case the
           authorization return string will be returned in the output";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description
            "The return code. Under normal operations this will
           return OperationInProgress";
        }

        leaf authorization-return-string {
          type string;
          description
            "The authorization return string.";
        }
      }
    }  // rpc authorization-code-return-offline

    rpc import-file {
      description
        "Import any of the various XML codes supported by smart
       Licensing from a file. This includes; authorization codes, policies,
       trust codes, RUM ACK response, SLR authorization codes, conversion ACK.";
      input {
        leaf file-path {
          type string {
            length "1..127";
          }
          mandatory true;
          description
            "The local or network file path to read from";
        }
      }

      output {
        leaf return-code {
          type error-enum;
          description "The return code.";
        }

        leaf confirmation-codes {
          type string;
          description
            "If the import command installed authorization codes and
           that install overwrote older authorization codes this list
           will contain the confirmation codes that must be returned
           to the Cisco Smart Software Manager (CSSM).";
        }
      }
    }  // rpc import-file

    notification ready {
      description
        "Smart Licensing on the product instance has initialized
       and is ready to accept the enable command.";
    }  // notification ready

    notification enabled {
      description
        "Smart Licensing on the product instance has been enabled.";
    }  // notification enabled

    notification registration-fail {
      description
        "Registration with Cisco failed.";
      uses notif-failure-data-group;
    }  // notification registration-fail

    notification enforcement-mode {
      description
        "This indicates how licenses are currently being enforced on the
       product instance.";
      leaf mode {
        type authorization-state-enum;
        description
          "The current enforcement mode for the licenses on the product instance.";
      }
    }  // notification enforcement-mode

    notification registration-success {
      description
        "Registration with Cisco was successful.";
    }  // notification registration-success

    notification registration-expired {
      description
        "The registration period has expired because the product instance
       has not communicated with the SSM in a very long time.";
      uses notif-failure-data-group;
    }  // notification registration-expired

    notification registration-renew-success {
      description
        "The registration renewal with Cisco was successful.";
    }  // notification registration-renew-success

    notification registration-renew-fail {
      description
        "The registration renewal with Cisco failed.";
      uses notif-failure-data-group;
    }  // notification registration-renew-fail

    notification authorization-renew-success {
      description
        "The autorization renewal was successful.
       Every 30 days the agent will automatically send the list of
       entitlements in use
       (even if they have not changed or the list is empty)
       to the SSM. The SSM will send back a status of Authorized or
       out of compliance.";
    }  // notification authorization-renew-success

    notification authorization-renew-fail {
      description
        "The autorization renewal failed.
       Every 30 days the agent will automatically send the list of
       entitlements in use
       (even if they have not changed or the list is empty)
       to the SSM. The SSM will send back a status of Authorized or
       out of compliance.";
      uses notif-failure-data-group;
    }  // notification authorization-renew-fail

    notification communications-fail {
      description
        "Communicatios with the SSM have failed.";
      uses notif-failure-data-group;
    }  // notification communications-fail

    notification communications-restored {
      description
        "Communications with the SSM have ben restored.";
    }  // notification communications-restored

    notification registration-out-of-range {
      description
        "The registration period time in the ID Certificate is
       out of the valid range after the system clock changed.
       This means the current time is either before the start date
       or after the expired date.
       Smart Licensing will allow a one hour grace period for the system clock
       to be changed back into the validity period of the certificate before it
       removes the certificate and de-registers the product.";
    }  // notification registration-out-of-range

    notification evaluation-expiration-warning {
      description
        "The evaluation period will expire soon.
       This notification will be sent prior to expiration at the following
       intervvals: 60 days,30 days, 21 days,14 days, 7 days,
       every day in the last week, every hour for the last day.";
      uses evaluation-time-left;
    }  // notification evaluation-expiration-warning

    notification evaluation-expired {
      description
        "The evaluation period has expired. This notification will be
       sent at the time of expiration and every hour after expiration
       unitl all licenses features are turned off or the device is
       registered.";
      leaf expire-time {
        type yang:date-and-time;
        description
          "The date and time the evaluation period expired.";
      }
    }  // notification evaluation-expired

    notification registration-expiration-warning {
      description
        "The registration period has expired. The normal registration
       period is one year and will be automatically renewed every
       six months. If the device fails to renew the registration
       because of continued communications failures for an additional
       six months the registration period will expire and the device
       will de-register.";
      leaf expire-time {
        type yang:date-and-time;
        description
          "The date and time the registration period expired.";
      }
    }  // notification registration-expiration-warning

    notification de-register-success {
      description
        "The smart licensing instance has been de-registered.
       This could be the result of a user action or an expired registration.";
    }  // notification de-register-success

    notification de-register-fail {
      description
        "de-registration has failed on the SSM or there was a communications
       failure so the SSM has not removed product instance from its database.
       Locally on the product instance all registration information has
       been removed.";
      uses notif-failure-data-group;
    }  // notification de-register-fail

    notification utility-expired {
      description
        "The certificate used for utility registration with a third party
       authenticator has expired. Probably because of continuous communications
       failures. The product instance will de-register.";
      uses notif-failure-data-group;
    }  // notification utility-expired

    notification utility-renewal-fail {
      description
        "The renewal of the certificate used for utility registration with a
       third party authenticator has failed. Possibly because of
       a communications failure. The product instance will try the renewal
       later.";
      uses notif-failure-data-group;
    }  // notification utility-renewal-fail

    notification utility-renewal-success {
      description
        "The renewal of the certificate used for utility registration with a
       third party authenticator was successful.";
    }  // notification utility-renewal-success

    notification utility-RUM-fail {
      description
        "Failed to sent a RUM (utility usage) report because of a
       communications error. the product instance will continue to
       attempting sending all reports until successful.";
      uses notif-failure-data-group;
    }  // notification utility-RUM-fail

    notification utility-reporting-started {
      description
        "The utility billing feature is enabled and is now sending
       utility usage reports.";
    }  // notification utility-reporting-started

    notification utility-reporting-stopped {
      description
        "The utility billing feature has been disabled and is no longer sending
       utility usage reports.";
    }  // notification utility-reporting-stopped

    container licensing {
      description
        "Container to hold config and state.";
      container config {
        description
          "Smart licensing configuration.";
        leaf enable {
          type boolean;
          description
            "Enable/disable smart licensing. If state:always-enabled is true then
           Smart Licensing is always enabled and config:enable will be
            silently ignored";
        }

        leaf custom-id {
          type string;
          description
            "A free form ID set by the customer which will be included
           in the utility usage (RUM) report and inthe message header.";
        }

        container privacy {
          description
            "Controls whether or not some information is sent in messages to the
            CSSM or satellite.";
          uses privacy-info;
        }  // container privacy

        container utility {
          description "Utility settings.";
          leaf utility-enable {
            type boolean;
            description
              "Indicates the customer's intent to start reporting
             utility usage information. This alone does not enable
             utility reporting. Either subscription information will be
             automatically downloaded from the SSM or a utility
             certificate we be loaded if the system registers with a
             Third Party Billing Platform.";
          }

          container customer-info {
            description
              "Customer address information that will be included in
             the utility usage reports.";
            uses customer-info;
          }  // container customer-info
        }  // container utility

        container usage {
          description
            "Setting for Usage reporting.";
          leaf interval {
            type uint32 {
              range "1..365";
            }
            units "days";
            description
              "Set the Usage Reporting interval in days.";
          }

          container customer-tags {
            description
              "Set the customer defined fields.";
            uses customer-tags-grouping;
          }  // container customer-tags
        }  // container usage

        container transport {
          description
            "Transport layer settings.";
          leaf transport-type {
            type transport-type-enum;
            description
              "The transport type. If transport-type
             is set to transport-type-callhome then any additional
             transport settings must be done from the callhome CLI.
             If the transport-type is set to transport-type-smart
             additional settings are available below.";
          }

          container transport-smart {
            when
              "../transport-type = 'transport-type-smart'";
            description
              "Settings for the smart transport.";
            choice url-setting {
              description
                "Set the URL(s) used for communications to the SSM,
               satellite or Third Party Billing Platform.";
              leaf url-default {
                type boolean;
                description
                  "Tell smart licensing to set the default URLs for both
                   url-registration and url-utility that point to
                   the Cisco SSM.";
              }
              container urls {
                description
                  "The URLS used for registration and utility reporting.
                   These should be set if the product instance will
                   communicate with a satellite or Third Party
                   Billing Platform.";
                leaf url-registration {
                  type inet:uri;
                  description
                    "Set the URL used for registration, authorization and
                     anything else not related to utility usage reporting.";
                }

                leaf url-utility {
                  type inet:uri;
                  description
                    "Set the URL to be used for sending utility usage
                     reports. This should be the same as url-registration
                     if you are using a satellite.";
                }
              }  // container urls
            }  // choice url-setting
          }  // container transport-smart

          container transport-cslu {
            description
              "The URL used for usage reporting via cisco smart license utility.
             These should be set if the product instance will
             communicate with a Cisco Smart License Utility (cslu).";
            leaf url-cslu {
              type inet:uri;
              description
                "Set the URL to be used for sending usage reports.";
            }
          }  // container transport-cslu
        }  // container transport
      }  // container config

      container state {
        config false;
        description "Smart licensing state.";
        leaf always-enabled {
          type boolean;
          description
            "Smart Licensing is always enabled. the smart-enabled leaf below
           will always be true. The config:enable setting above will be silently
           ignored by Smart licensing";
        }

        leaf smart-enabled {
          type boolean;
          description
            "Is smart licensing enabled. If always-enabled above is true then
            smart licensing is always enabled and can not be disabled.";
        }

        leaf version {
          type string {
            length "1..255";
          }
          description
            "The smart licensing version in use.";
        }

        container state-info {
          when "../smart-enabled = 'true'";
          description
            "Smart licensing state information.
              This is only valid if smart-enabled = true.";
          container registration {
            description
              "State of license registration.";
            uses registration-state;
          }  // container registration

          container authorization {
            description
              "State of license authorization.";
            uses authorization-state;
          }  // container authorization

          container utility {
            description
              "State of utility reporting.";
            uses utility-state;
          }  // container utility

          leaf custom-id {
            type string;
            description
              "The custom ID set by the customer that will be included in the
             utility usage (RUM) report and in th emessage header";
          }

          container transport {
            description
              "State of the transport.";
            uses transport-state;
          }  // container transport

          container privacy {
            description
              "State of the privacy settings.";
            uses privacy-info;
          }  // container privacy

          container evaluation {
            description
              "State of the evaluation period.";
            uses eval-period-state;
          }  // container evaluation

          container udi {
            description "UDI of the system.";
            uses udi;
          }  // container udi

          list usage {
            key "entitlement-tag";
            description
              "List of license (entitlement tag) usage information.
             This only contains the information for licenses that are in use.";
            uses license-usage;
          }  // list usage

          container policy {
            description
              "Policy information.";
            uses policy-state-grouping;
          }  // container policy

          list trust-code {
            key "key_udi";
            description
              "State of trust code installs for every device in an HA
             configuration. If no HA then this will be a list of one
             item.";
            uses trust-code-state-grouping;
          }  // list trust-code

          list conversion {
            key "key_udi";
            description
              "Conversion status for each product instance in an HA
             configuration";
            uses conversion-state-grouping;
          }  // list conversion

          list rum-reports-closed-keys {
            key "rum-report-key";
            description
              "The list of RUM report keys, for all closed and
             unacked reports, that can be used to do a
             lookup in the rum-reports-closed list.";
            uses rum-report-summary-grouping;
          }  // list rum-reports-closed-keys

          container rum-ack {
            description
              "RUM ACK status information";
            uses rum-ack-state-grouping;
          }  // container rum-ack

          list factory-purchase {
            key "key_udi";
            description
              "In an HA configuration this contains information about
             licenses purchased and installed for each
             device at manufacturing time.
             If there is no HA then this will be a list of one item.";
            uses factory-purchase-state-grouping;
          }  // list factory-purchase

          container imported-authorizations {
            description
              "Information about all licenses that are authorized
             and how they were authorized";
            uses license-auth-status-info;
          }  // container imported-authorizations
        }  // container state-info
      }  // container state
    }  // container licensing
  }  // module cisco-smart-license