module lisp-address-types {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:lisp-address-types";

    prefix lisp;

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

    organization
      "IETF LISP (Locator/ID Separation Protocol) Working Group";

    contact "lisp@ietf.org";

    description
      "This YANG module defines the LISP Canonical Address Formats (LCAF)
     for LISP. The module can be extended by vendors
     to define vendor-specific parameters.

     Copyright (c) 2015 IETF Trust and the persons identified as
     authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Simplified BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (http://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC 6338; see
     the RFC itself for full legal notices.

    ";

    revision "2015-03-23" {
      description "Initial revision.";
    }


    typedef instance-id-type {
      type uint32 {
        range "0..16777214";
      }
    }

    typedef simple-address {
      type union {
        type inet:ip-address;
        type yang:mac-address;
      }
    }

    grouping lcaf-address {
      leaf lcaf-type {
        type enumeration {
          enum "null" {
            value 0;
          }
          enum "afi-list" {
            value 1;
          }
          enum "instance-id" {
            value 2;
          }
          enum "as-number" {
            value 3;
          }
          enum "application-data" {
            value 4;
          }
          enum "geo-coordinates" {
            value 5;
          }
          enum "opaque-key" {
            value 6;
          }
          enum "nat-ttraversal" {
            value 7;
          }
          enum "nonce-locator" {
            value 8;
          }
          enum "multicast-info" {
            value 9;
          }
          enum "explicit-locator-path" {
            value 10;
          }
          enum "security-key" {
            value 11;
          }
          enum "source-dest-key" {
            value 12;
          }
          enum "replication-list" {
            value 13;
          }
          enum "json-data-model" {
            value 14;
          }
          enum "key-value-address" {
            value 15;
          }
          enum "encapsulation-format" {
            value 16;
          }
        }
      }

      choice address {
        container as-number {
          when "lcaf-type = as-number";
          leaf as {
            type inet:as-number;
          }

          leaf address {
            type simple-address;
          }
        }  // container as-number
        container sourc-dest-key {
          when "lcaf-type = source-dest-key";
          leaf source {
            type inet:ip-prefix;
          }

          leaf dest {
            type inet:ip-prefix;
          }
        }  // container sourc-dest-key
        container explicit-locator-path {
          when
            "lcaf-type = explicit-locator-path";
          list hop {
            key "address";
            leaf address {
              type simple-address;
            }

            leaf lrs-bits {
              type bits {
                bit lookup {
                  position 0;
                }
                bit rloc-probe {
                  position 1;
                }
                bit strict {
                  position 2;
                }
              }
            }
          }  // list hop
        }  // container explicit-locator-path
      }  // choice address
    }  // grouping lcaf-address

    grouping lisp-address {
      leaf afi {
        type enumeration {
          enum "ipv4" {
            value 1;
          }
          enum "ipv6" {
            value 2;
          }
          enum "mac-address" {
            value 6;
          }
          enum "lcaf" {
            value 16387;
          }
        }
      }

      leaf instance-id {
        type instance-id-type;
      }

      choice address {
        case ipv4 {
          when "afi = ipv4";
          leaf ipv4 {
            type inet:ipv4-address;
          }
        }  // case ipv4

        case ipv6 {
          when "afi = ipv6";
          leaf ipv6 {
            type inet:ipv6-address;
          }
        }  // case ipv6

        case mac-address {
          when "afi = mac-address";
          leaf mac-address {
            type yang:mac-address;
          }
        }  // case mac-address

        case lcaf {
          when "afi = lcaf";
          container lcaf {
            uses lcaf-address;
          }  // container lcaf
        }  // case lcaf
      }  // choice address
    }  // grouping lisp-address
  }  // module lisp-address-types