cisco-smart-license

Smart licensing configuration, RPC, notification and operational data. Copyright (c) 2016-2020 by Cisco Systems, Inc. All right...

  • Version: 2021-03-01

    cisco-smart-license@2021-03-01


    
      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";
        }
    
        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.";
          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.";
          }
        }  // 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.";
          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.";
          }
        }  // 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.";
          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.";
          }
        }  // 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.";
          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.";
          }
        }  // notification authorization-renew-fail
    
        notification communications-fail {
          description
            "Communicatios with the SSM have 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.";
          }
        }  // 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.";
          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.";
          }
        }  // 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.";
          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.";
          }
        }  // 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.";
          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.";
          }
        }  // 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.";
          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.";
          }
        }  // 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.";
          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.";
          }
        }  // 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.";
              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.";
              }
            }  // 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.";
                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.";
                }
              }  // 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.";
                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";
                }
              }  // 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.";
                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.";
                  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.";
                  }
                }  // 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.";
                  }
    
                  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.";
                  }
                }  // 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.";
                }
              }  // container registration
    
              container authorization {
                description
                  "State of license authorization.";
                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.";
                  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.";
                  }
                }  // 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.";
                  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.";
                  }
                }  // 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.";
                  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.";
                  }
    
                  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.";
                  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.";
                  }
                }  // container authorization-authorization-expired
              }  // container authorization
    
              container utility {
                description
                  "State of utility reporting.";
                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.";
                  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.";
                  }
                }  // container customer-info
              }  // 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.";
                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
              }  // container transport
    
              container privacy {
                description
                  "State of the privacy settings.";
                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.";
                }
              }  // container privacy
    
              container evaluation {
                description
                  "State of the evaluation period.";
                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
              }  // container evaluation
    
              container udi {
                description "UDI of the system.";
                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.";
                }
              }  // 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.";
                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.";
                }
              }  // list usage
    
              container policy {
                description
                  "Policy information.";
                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.";
                  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.";
                  }
                }  // container policy-enforced
    
                container policy-export {
                  description
                    "Attributes for an export license.";
                  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.";
                  }
                }  // container policy-export
    
                container policy-subscription {
                  description
                    "Attributes for an subscription license.";
                  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.";
                  }
                }  // container policy-subscription
    
                container policy-perpetual {
                  description
                    "Attributes for a perpetual license.";
                  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.";
                  }
                }  // container policy-perpetual
              }  // 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.";
                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.";
                  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.";
                  }
                }  // container udi
              }  // list trust-code
    
              list conversion {
                key "key_udi";
                description
                  "Conversion status for each product instance in an HA
                 configuration";
                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";
                  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.";
                  }
                }  // container udi
              }  // 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.";
                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.";
                  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.";
                  }
                }  // 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.";
                }
    
                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.";
                }
              }  // list rum-reports-closed-keys
    
              container rum-ack {
                description
                  "RUM ACK status information";
                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.";
                }
              }  // 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.";
                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";
                  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.";
                  }
                }  // container udi
    
                list basic-license-info {
                  key "entitlement-tag";
                  description
                    "The 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.";
                  }
    
                  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";
                  }
                }  // list basic-license-info
              }  // list factory-purchase
    
              container imported-authorizations {
                description
                  "Information about all licenses that are authorized
                 and how they were authorized";
                list overall-status {
                  key "key_udi";
                  description
                    "List of the authroization code install information for
    each device";
                  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";
                    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.";
                    }
                  }  // container udi
    
                  list installed-list {
                    key "install-type";
                    description
                      "List of all authorizations installed on this device";
                    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.";
                    }
                  }  // list installed-list
                }  // 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.";
                  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.";
                  }
                }  // list authorization-list
              }  // container imported-authorizations
            }  // container state-info
          }  // container state
        }  // container licensing
      }  // module cisco-smart-license
    

© 2023 YumaWorks, Inc. All rights reserved.