module Cisco-IOS-XR-ppp-ma-gbl-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-ppp-ma-gbl-cfg";

    prefix ppp-ma-gbl-cfg;

    import ietf-inet-types {
      prefix inet;
    }
    import cisco-semver {
      prefix semver;
    }
    import Cisco-IOS-XR-subscriber-infra-tmplmgr-cfg {
      prefix a1;
    }

    organization "Cisco Systems, Inc.";

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

    description
      "This module contains a collection of YANG definitions
     for Cisco IOS-XR ppp-ma-gbl package configuration.
     
     This YANG module augments the
       Cisco-IOS-XR-subscriber-infra-tmplmgr-cfg
     module with configuration data.
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

    revision "2017-11-05" {
      description
        "Corrected boolean values in when statements.";
    }

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

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

    semver:module-version "1.0.1";

    typedef Ppp-authentication-method-gbl {
      type enumeration {
        enum "pap" {
          value 1;
          description "PAP";
        }
        enum "chap" {
          value 2;
          description "CHAP";
        }
        enum "ms-chap" {
          value 3;
          description "MS CHAP";
        }
      }
      description
        "Ppp authentication method gbl";
    }

    augment /a1:dynamic-template/a1:ppps/a1:ppp {
      description
        "This augment extends the configuration data of
       'Cisco-IOS-XR-subscriber-infra-tmplmgr-cfg'";
      container ppp-template {
        description
          "PPP template configuration data";
        container fsm {
          description
            "PPP FSM global template configuration data";
          leaf max-consecutive-conf-naks {
            type uint32 {
              range "2..10";
            }
            default "5";
            description
              "This specifies the maximum number of
             consecutive Conf-Naks";
          }

          leaf max-unacknowledged-conf-requests {
            type uint32 {
              range "4..20";
            }
            default "10";
            description
              "This specifies the maximum number of
             unacknowledged Conf-Requests";
          }

          leaf retry-timeout {
            type uint32 {
              range "1..10";
            }
            default "3";
            description
              "This specifies the maximum time to wait for a
             response during PPP negotiation";
          }

          leaf protocol-reject-timeout {
            type uint32 {
              range "1..60";
            }
            default "60";
            description
              "This specifies the maximum time to wait before
             sending Protocol Reject";
          }
        }  // container fsm

        container lcp {
          description
            "PPP LCP global template configuration data";
          container absolute-timeout {
            description
              "This specifies the session absolute timeout
             value";
            leaf minutes {
              type uint32 {
                range "0..35000000";
              }
              description "Minutes";
            }

            leaf seconds {
              type uint32 {
                range "0..59";
              }
              description "Seconds";
            }
          }  // container absolute-timeout

          container delay {
            description
              "This specifies the time to delay before
             starting active LCPnegotiations";
            leaf seconds {
              type uint32 {
                range "0..255";
              }
              description "Seconds";
            }

            leaf milliseconds {
              type uint32 {
                range "0..999";
              }
              description "Milliseconds";
            }
          }  // container delay

          container authentication {
            description
              "PPP authentication parameters";
            container methods {
              description
                "This specifies the PPP link authentication
               method";
              leaf-list method {
                type Ppp-authentication-method-gbl;
                max-elements 3;
                description
                  "Select between one and three authentication
                 methods in order of preference";
              }
            }  // container methods

            leaf chap-host-name {
              type string;
              description
                "This specifies the CHAP hostname";
            }

            leaf pap {
              type uint32;
              description
                "<1> for accepting null-passwordduring
               authentication";
            }

            leaf mschap-host-name {
              type string;
              description
                "This specifies the MS-CHAP hostname";
            }

            leaf max-authentication-failures {
              type uint32 {
                range "0..10";
              }
              description
                "This specifies whether to allow multiple
               authentication failures and, if so, how many";
            }

            leaf timeout {
              type uint32 {
                range "3..30";
              }
              default "10";
              description
                "Maximum time to wait for an authentication
               response";
            }
          }  // container authentication

          container keepalive {
            description
              "This specifies the rate at which EchoReq
             packets are sent";
            leaf keepalive-disable {
              type boolean;
              description
                "TRUE to disable keepalives, FALSE to specify
               a new keepalive interval";
            }

            leaf interval {
              when
                "../keepalive-disable = 'false'" {
                description
                  "../KeepaliveDisable = 'false'";
              }
              type uint32 {
                range "10..180";
              }
              description
                "The keepalive interval. Leave unspecified
               when disabling keepalives";
            }

            leaf retry-count {
              when
                "../keepalive-disable = 'false'" {
                description
                  "../KeepaliveDisable = 'false'";
              }
              type uint32 {
                range "1..255";
              }
              description
                "The keepalive retry count. Leave unspecified
               when disabling keepalives";
            }
          }  // container keepalive

          leaf renegotiation {
            type empty;
            description
              "Specify whether to ignore attempts to
             renegotiate LCP";
          }

          leaf service-type {
            type uint32 {
              range "0..15";
            }
            default "0";
            description
              "This is the Service-Type";
          }

          leaf send-term-request-on-shut-down {
            type empty;
            description
              "Enable Sending LCP Terminate request on
             shutdown";
          }

          leaf mru-ignore {
            type empty;
            description
              "Ignore MRU negotiated with peer while setting
             interface BW";
          }
        }  // container lcp

        container ipv6cp {
          description
            "PPP IPv6CP global template configuration data";
          leaf passive {
            type empty;
            description
              "Specify whether to run IPv6CP in Passive mode";
          }

          leaf renegotiation {
            type empty;
            description
              "Specify whether to ignore attempts to
             renegotiate IPv6CP";
          }

          leaf peer-interface-id {
            type string;
            description
              "Specify the Interface-Id to impose on the peer";
          }

          leaf protocol-reject {
            type empty;
            description
              "Specify whether to protocol reject IPv6CP";
          }
        }  // container ipv6cp

        container ipcp {
          description
            "PPP IPCP global template configuration data";
          container wins {
            description
              "IPCP WINS parameters";
            container wins-addresses {
              description
                "Specify WINS address(es) to provide";
              leaf primary {
                type inet:ipv4-address-no-zone;
                description
                  "Primary WINS IP address";
              }

              leaf secondary {
                type inet:ipv4-address-no-zone;
                description
                  "Secondary WINS IP address";
              }
            }  // container wins-addresses
          }  // container wins

          container dns {
            description
              "IPCP DNS parameters";
            container dns-addresses {
              description
                "Specify DNS address(es) to provide";
              leaf primary {
                type inet:ipv4-address-no-zone;
                description
                  "Primary DNS IP address";
              }

              leaf secondary {
                type inet:ipv4-address-no-zone;
                description
                  "Secondary DNS IP address";
              }
            }  // container dns-addresses
          }  // container dns

          container peer-address {
            description
              "IPCP address parameters";
            leaf default {
              type inet:ipv4-address-no-zone;
              description
                "Specify an IP address to assign to peers
               through IPCP";
            }

            leaf pool {
              type string;
              description
                "Accepts an IP address from the peer if in the
               pool, else allocates one from the pool";
            }
          }  // container peer-address

          leaf renegotiation {
            type empty;
            description
              "Specify whether to ignore attempts to
             renegotiate IPCP";
          }

          leaf passive {
            type empty;
            description
              "Specify whether to run IPCP in Passive mode";
          }

          leaf protocol-reject {
            type empty;
            description
              "Specify whether to protocol reject IPCP";
          }

          leaf peer-netmask {
            type inet:ipv4-address-no-zone;
            description
              "Specify the IPv4 netmask to negotiate for the
             peer";
          }
        }  // container ipcp
      }  // container ppp-template
    }
  }  // module Cisco-IOS-XR-ppp-ma-gbl-cfg