module GENERIC-RESOURCE-API {

   namespace "org:onap:sdnc:northbound:generic-resource";

   prefix generic-resource-api;

   import ietf-inet-types { prefix "inet"; revision-date "2010-09-24"; }

   import ietf-yang-types { prefix yang; }

   revision "2017-08-24" {
     description
        "ONAP Amsterdam version";
   }

   grouping service-model-infrastructure {
      list service {
         key "service-instance-id";
         leaf service-instance-id {
            description "Keep as M";
            type string;
            mandatory true;
         }
         uses service-data;
         uses service-status;
      }
   }
   grouping service-data {
      container service-data {
         uses service-operation-information;
         uses service-topology;
         uses service-level-oper-status;
         container networks {
            list network {
               key "network-id";
               leaf network-id {
                  type string;
                  mandatory true;
               }
               container network-data {
                  uses network-operation-information;
                  uses network-topology;
                  container network-provided-allotted-resources {
                     leaf-list network-provided-ar-id {
                        description "List of allotted resources using capacity from this network";
                        type string;
                        ordered-by user;
                     }
                  }
                  uses network-level-oper-status;
               }
            }
         }
         container vnfs {
            list vnf {
               key "vnf-id";
               leaf vnf-id {
                  type string;
                  mandatory true;
               }
               container vnf-data {
                  uses vnf-operation-information;
                  uses vnf-topology;
                  container vnf-network-collections {
                     uses vnf-network-collection;
                  }
                  container vnf-sub-interface-groups {
                     uses vnf-sub-interface-group;
                  }
                  container vnf-provided-allotted-resources {
                     leaf-list vnf-provided-ar-id {
                        description "List of allotted resources using capacity from this vnf";
                        type string;
                        ordered-by user;
                     }
                  }
                  uses vnf-level-oper-status;
                  container vf-modules {
                     list vf-module {
                        key "vf-module-id";
                        leaf vf-module-id {
                           type string;
                           mandatory true;
                        }
                        container vf-module-data {
                           uses vf-module-operation-information;
                           uses vf-module-topology;
                           uses vf-module-level-oper-status;
                        }
                     }
                  }
               }
            }
         }
         container consumed-allotted-resources {
            list consumed-allotted-resource {
               key "allotted-resource-id";
               uses allotted-resource-info;
            }
         }
         container provided-allotted-resources {
            list provided-allotted-resource {
               key "allotted-resource-id";
               uses allotted-resource-info;
            }
         }
         container provided-configurations {
            list provided-configuration {
               key "configuration-id";
               uses configuration-info;
            }
         }
         container vnfc-instance-groups {
            uses vnfc-instance-group;
         }
         container network-instance-groups {
            uses network-instance-group;
         }
         container forwarding-paths {
            list forwarding-path {
               key "forwarding-path-id";
               leaf forwarding-path-id {
                  description "Generated by SDNC";
                  type string;
                  mandatory true;
               }
               uses forwarding-path-information;
            }
         }
      }
   }
   grouping service-status {
      container service-status {
         leaf response-code {
            type string;
         }
         leaf response-message {
            type string;
         }
         leaf final-indicator {
            type string;
         }
         leaf request-status {
            type enumeration {
               enum "synccomplete";
               enum "asynccomplete";
               enum "notifycomplete";
            }
         }
         leaf action {
            description "value would one of possible request-actions; match the list in service-data oper-status";
            type string;
         }
         leaf rpc-name {
            type string;
         }
         leaf rpc-action {
            description "this is the svc-action from the incoming request";
            type enumeration {
               enum "assign";
               enum "activate";
               enum "configure";
               enum "delete";
               enum "unassign";
               enum "deactivate";
               enum "create";
            }
         }
         leaf response-timestamp {
            type string;
         }
      }
   }
   grouping service-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses service-request-input;
   }
   grouping service-request-input {
      container service-request-input {
         leaf service-instance-name {
            type string;
         }
         container service-input-parameters {
            uses param;
         }
      }
   }
   grouping service-topology {
      container service-topology {
         uses service-topology-identifier;
         uses onap-model-information;
         uses service-assignments;
         uses service-parameters;
      }
   }
   grouping service-topology-identifier {
      container service-topology-identifier {
         leaf service-instance-id {
            description "repeated";
            type string;
         }
         leaf service-type {
            description "tag labeled subscription-service-type in the service-information input";
            type string;
         }
         leaf service-id {
            description "from MSO input on STO assign";
            type string;
         }
         leaf service-instance-name {
            description "optionally comes from service-request-input container or is assigned by sdn-c";
            type string;
         }
         leaf global-customer-id {
            type string;
         }
      }
   }
   grouping service-assignments {
      container service-assignments {
      }
   }
   grouping service-parameters {
      container service-parameters {
         list service-parameter {
            key "service-parameter-name";
            leaf service-parameter-name {
               type string;
            }
            leaf service-parameter-value {
               type string;
            }
         }
      }
   }
   grouping service-level-oper-status {
      container service-level-oper-status {
         uses oper-status-data;
      }
   }
   grouping network-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses network-information;
      uses network-request-input;
   }
   grouping network-information {
      container network-information {
         leaf network-id {
            type string;
         }
         leaf network-type {
            type string;
         }
         leaf network-technology {
             type string;
         }
         leaf from-preload {
            description "Indicates if source is preload data";
            type boolean;
         }
         uses onap-model-information;
      }
   }
   grouping network-request-input {
      container network-request-input {
         leaf network-name {
            type string;
         }
         uses region-identifier;
         container network-input-parameters {
            uses param;
         }
         leaf network-instance-group-id {
            description "When network has instance-group role in service model";
            type string;
         }
      }
   }
   grouping network-topology {
      container network-topology {
         uses network-topology-identifier-structure;
         uses region-identifier;
         uses onap-model-information;
         uses network-assignments;
         uses network-parameters;
      }
   }
   grouping network-topology-identifier-structure {
      container network-topology-identifier-structure {
         leaf network-id {
            type string;
         }
         leaf network-name {
            type string;
         }
         leaf network-role {
            type string;
         }
         leaf network-type {
            type string;
         }
         leaf network-instance-group-id {
            description "When network is part of network instance-Group-data & instance Group in A&AI";
            type string;
         }
         leaf network-technology {
            type string;
         }
         leaf eipam-v4-address-plan {
            type string;
         }
         leaf eipam-v6-address-plan {
            type string;
         }
         leaf is-trunked {
             type boolean;
         }
         leaf segmentation-id {
            type string;
         }
         container related-networks {
            uses related-network;
         }
      }
   }
   grouping network-assignments {
      container network-assignments {
      }
   }
   grouping network-parameters {
      container network-parameters {
         list network-parameter {
            key "network-parameter-name";
            leaf network-parameter-name {
               type string;
            }
            leaf network-parameter-value {
               type string;
            }
         }
      }
   }
   grouping network-instance-group {
      list network-instance-group {
         key "network-instance-group-id";
         leaf network-instance-group-id {
            description "Also a Key in Network Instance Group in A&AI";
            type string;
            mandatory true;
         }
         leaf network-instance-group-function {
            type string;
         }
         leaf service-instance-id {
            type string;
         }
         uses onap-model-information;
         container subnet-assignment-policy {
            leaf subnet-use {
               description "Current valid values - unique, shared (default)";
               type string;
            }
         }
         container vpn-binding-policy {
            leaf vpn-binding {
               type string;
            }
            leaf vpn-name {
               type string;
            }
            leaf vpn-type {
               type string;
            }
            leaf vpn-platform {
               type string;
            }
            leaf global-route-target {
               type string;
            }
            leaf route-target-role {
               type string;
            }
         }
         uses aggregate-routes;
         uses subnets;
         leaf subnet-key-value {
            description "key-value provided to EIPAM when  creating shared subnet";
            type string;
         }
         container networks {
            list network {
               key "network-id";
               leaf network-id {
                  description "Index into network-topology-identifier structure";
                  type string;
                  mandatory true;
               }
               leaf neutron-network-id {
                  description "Neutron-network-id assigned by PO/RO";
                  type string;
               }
               uses vpn-bindings;
               leaf vlan-tag-id {
                  type uint32;
               }
               leaf network-status {
                  description "assigned, unassigned";
                  type string;
               }
               container customer-bonding-requests {
                  list customer-bonding-request {
                     key "configuration-id";
                     leaf configuration-id {
                        description "e.g. vlan network receptor configuration id";
                        type string;
                     }
                  }
               }
            }
         }
      }
   }
   grouping network-level-oper-status {
      container network-level-oper-status {
         uses oper-status-data;
      }
   }
   grouping vnf-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses vnf-information;
      uses vnf-request-input;
      uses license-information;
   }
   grouping vnf-information {
      container vnf-information {
         leaf vnf-id {
            type string;
         }
         leaf vnf-type {
            type string;
         }
         leaf vnf-name {
            type string;
         }
         uses onap-model-information;
      }
   }
   grouping vnf-request-input {
      container vnf-request-input {
         leaf request-version {
            type string;
         }
         leaf vnf-name {
            type string;
         }
         uses region-identifier;
         container vnf-networks {
            list vnf-network {
               key "network-role";
               uses vnf-network-data;
            }
         }
         list vnf-network-instance-group-ids {
            key "vnf-network-instance-group-id";
            leaf vnf-network-instance-group-id {
               description "List of vnf network-instance-group";
               type string;
            }
         }
         container vnf-input-parameters {
            uses param;
         }
      }
   }
   grouping vnf-topology {
      container vnf-topology {
         uses vnf-topology-identifier-structure;
         uses region-identifier;
         uses onap-model-information;
         uses vnf-resource-assignments;
         container vnf-parameters-data {
            uses param;
         }
         leaf sdnc-generated-cloud-resources {
            description "Indicate if source is sdnc generated cloud param";
            type boolean;
         }
      }
   }
   grouping vnf-topology-identifier-structure {
      container vnf-topology-identifier-structure {
         leaf vnf-id {
            type string;
         }
         leaf vnf-type {
            description "In preload tree, this label is used for the vf-module-type";
            type string;
         }
         leaf nf-type {
            type string;
         }
         leaf nf-role {
            type string;
         }
         leaf nf-function {
            type string;
         }
         leaf nf-code {
            description "used in vnf naming";
            type string;
         }
         leaf vnf-name {
            description "optionally comes from vnf-request-input container or is assigned by sdn-c";
            type string;
         }
      }
   }
   grouping vnf-resource-assignments {
      container vnf-resource-assignments {
         leaf vnf-status {
            description "Orchestration status from AAI - to be set by SDNC";
            type string;
         }
         container availability-zones {
            leaf-list availability-zone {
               description "Openstack availability zone name or UUID";
               type string;
               ordered-by user;
            }
            leaf max-count {
               description "From the TOSCA data. Indicates the largest availability zone count needed by any vf-module in the VNF.";
               type uint8;
            }
         }
         container vnf-networks {
            list vnf-network {
               key "network-role";
               uses vnf-network-data;
            }
         }
      }
   }
   grouping vnf-network-data {
      leaf network-role {
         description "A Network Role to which a VNF must connect";
         type string;
      }
      leaf network-name {
         description "Unique Neutron UUID of an instance of the network role ";
         type string;
      }
      leaf neutron-id {
         description "Unique Neutron UUID of an instance of the network role ";
         type string;
      }
      leaf network-id {
         description "Unique Neutron UUID of an instance of the network role ";
         type string;
      }
      leaf contrail-network-fqdn {
         description "contrail network policy object";
         type string;
      }
      container subnets-data {
         list subnet-data {
            key "sdnc-subnet-id";
            leaf sdnc-subnet-id {
               description "Unique SDNC generated UUID of the subnet. Key into A&AI instance.This maps to ipv4-key-subnet-id and ipv6-key-subnet-id in VNF-API";
               type string;
            }
            leaf subnet-role {
               description "Subnet Role for the subnet";
               type string;
            }
            leaf subnet-name {
               description "Populated for preload only";
               type string;
            }
            leaf ip-version {
               description "Should be ipv4 or ipv6";
               type string;
            }
            leaf subnet-id {
               description "subnet UUID to be passed into the HEAT template";
               type string;
            }
            leaf dhcp-enabled {
               description "Indicator to use this subnet for  DHCP ";
               type enumeration {
                  enum "Y";
                  enum "N";
               }
            }
            leaf network-start-address {
               description "start-address of the subnet";
               type inet:ip-address;
            }
            leaf gateway-address {
               description "subnet gateway address";
               type inet:ip-address;
            }
            leaf cidr-mask {
               description "cidr mask";
               type string;
            }
         }
      }
      leaf is-trunked {
          type boolean;
       }
       leaf segmentation-id {
          type string;
       }
       container related-networks {
          uses related-network;
       }
   }
   grouping vnf-level-oper-status {
      container vnf-level-oper-status {
         uses oper-status-data;
      }
   }
   grouping vf-module-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses vnf-information;
      uses vf-module-information;
      uses vf-module-request-input;
   }
   grouping vf-module-information {
      container vf-module-information {
         leaf vf-module-id {
            type string;
         }
         leaf vf-module-type {
            type string;
         }
         leaf from-preload {
            description "Indicates if source is preload data";
            type boolean;
         }
         uses onap-model-information;
      }
   }
   grouping vf-module-request-input {
      container vf-module-request-input {
         leaf request-version {
            description "keep this?";
            type string;
         }
         leaf vf-module-name {
            type string;
         }
         uses region-identifier;
         container vf-module-input-parameters {
            uses param;
         }
      }
   }
   grouping vf-module-topology {
      container vf-module-topology {
         uses vf-module-topology-identifier;
         uses region-identifier;
         uses onap-model-information;
         uses vf-module-assignments;
         container vf-module-parameters {
            uses param;
         }
         leaf sdnc-generated-cloud-resources {
            description "Indicate if source is sdnc-generated-cloud-resources.When true, the parameters are literal HEAT template parameter names;When false, the parameters need to be converted to HEAT format"; 
            type boolean;
         }
      }
   }
   grouping vf-module-topology-identifier {
      container vf-module-topology-identifier {
         leaf vf-module-id {
            description "vf-module id";
            type string;
         }
         leaf vf-module-name {
            description "vf-module-name";
            type string;
         }
         leaf vf-module-type {
            type string;
         }
      }
   }
   grouping vf-module-assignments {
      container vf-module-assignments {
         leaf vf-module-status {
            description "Orchestration status from AAI - to be set by SDNC";
            type string;
         }
         container vms {
            list vm {
               key "vm-type";
               uses vm-topology-data;
            }
         }
         uses vlan-vnfc-instance-groups;
      }
   }
   grouping vm-topology-data {
      leaf vm-type {
         type string;
         mandatory true;
      }
      uses onap-model-information;
      leaf nfc-naming-code {
         description "used in vm naming(draft 29: changed from nfc-code)";
         type string;
      }
      leaf vm-type-tag {
         description "from tosca data on vfc";
         type string;
      }
      leaf vm-count {
         type uint8;
      }
      container vm-names {
         leaf-list vm-name {
            type string;
            ordered-by user;
         }
         list vnfc-names {
            key "vnfc-name";
            leaf vnfc-name {
               type string;
            }
            container vnfc-networks {
               uses vnfc-network-data;
            }
         }
      }
      container vm-networks {
         list vm-network {
            key "network-role";
            uses vm-network-data;
         }
      }
   }
   grouping vnfc-network-data {
      list vnfc-network-data {
         key "vnfc-network-role";
         leaf vnfc-network-role {
            type string;
            mandatory true;
         }
         leaf vnfc-type {
            type string;
         }
         uses connection-point;
         container vnfc-ports {
            list vnfc-port {
               key "vnfc-port-id";
               leaf vnfc-port-id {
                  description "Port(s) with a given network-role are assigned vnfc-port-id from series - 01, 02, 03 ...Example: VM with two ports with network-role =X and another 2 ports with network-role=Y vnfc-port-ids:01 - 1st port with network-role=X02 - 2nd port with network-role=X01 - 1st port with network-role=Y02 - 2nd port with network-role=Y";
                  type string;
                  mandatory true;
               }
               leaf common-sub-interface-role {
                  description "If sub-interfaces have common interface role (network role)";
                  type string;
               }
               container vnic-sub-interfaces {
                  uses sub-interface-network-data;
               }
            }
         }
         list vnfc-subnet {
            key "vnfc-subnet-role";
            leaf vnfc-subnet-role {
               description "Default value if subnet role is not defined.";
               type string;
               mandatory true;
            }
            list vnfc-ip-assignments {
               key "vnfc-address-family";
               leaf vnfc-address-family {
                  description "indicates if this is IpV4 or IpV6";
                  type enumeration {
                     enum "ipv4";
                     enum "ipv6";
                  }
               }
               leaf vnfc-subnet-dhcp {
                  description "Indicator to use DHCP for IP assignment. Unless dhcp=N, we wouldnt have any IPs here, since they would not be SDNC assigned ";
                  type enumeration {
                     enum "Y";
                     enum "N";
                  }
               }
               leaf vnfc-subnet-ip-count {
                  description "The number of IP addresses to be assigned per vnfc for this subnet role";
                  type uint8;
               }
               list vnfc-subnet-ip {
                  key "vnfc-ip-address";
                  leaf vnfc-ip-address {
                     description "Either IpV4 IP or IpV6 IP addresses should be present";
                     type inet:ip-address;
                  }
                  leaf vnfc-client-key {
                     type string;
                  }
                  leaf ip-type {
                     description "Capture what type of IP this is, if is virtual IP (AKA, floating IP) or Fixed IP. ";
                     type enumeration {
                        enum "FIXED";
                        enum "VIP";
                     }
                  }
               }
            }
         }
      }
   }
   grouping vm-network-data {
      leaf network-role {
         description "network (identified by role) that this VM connects to.  Should also be included in the vnf-networks for the containing VNF";
         type string;
         mandatory true;
      }
      leaf network-role-tag {
         type string;
      }
      container network-information-items {
         list network-information-item {
            key "ip-version";
            leaf ip-version {
               description "Use ipv4 or ipv6";
               type string;
            }
            leaf use-dhcp {
               description "Indicator to use DHCP on this network for this VM";
               type enumeration {
                  enum "Y";
                  enum "N";
               }
            }
            leaf ip-count {
               description "The number of ip addresses to be assigned per vm for this network role";
               type uint8;
            }
            container network-ips {
               leaf-list network-ip {
                  description "List of assigned ip addresses of type ip-version on a network";
                  type string;
                  ordered-by user;
               }
            }
         }
      }
      container mac-addresses {
         leaf-list mac-address {
            description "List of network assignments for this vm-type";
            type string;
            ordered-by user;
         }
      }
      container floating-ips {
         leaf-list floating-ip-v4 {
            description "Floating ipv4 for VMs of a given type on this network";
            type inet:ip-address;
            ordered-by user;
         }
         leaf-list floating-ip-v6 {
            description "Floating ipv6 for VMs of a given type on this network";
            type inet:ipv6-address;
            ordered-by user;
         }
      }
      container interface-route-prefixes {
         leaf-list interface-route-prefix {
            description "ordered-by: user";
            type string;
            ordered-by user;
         }
      }
      container sriov-parameters {
         container heat-vlan-filters {
            leaf-list heat-vlan-filter {
               type string;
               ordered-by user;
            }
         }
         container application-tags {
            container c-tags {
               leaf-list c-tag {
                  type string;
                  ordered-by user;
               }
            }
            container s-tags {
               leaf-list s-tag {
                  type string;
                  ordered-by user;
               }
            }
         }
      }
      leaf is-trunked {
         type boolean;
      }
      leaf segmentation-id {
         type string;
      }
      container related-networks {
         uses related-network;
      }
   }
   grouping vf-module-level-oper-status {
      container vf-module-level-oper-status {
         uses oper-status-data;
      }
   }
   grouping allotted-resource-info {
      leaf allotted-resource-id {
         type string;
      }
      leaf allotted-resource-type {
         description "Not an enum, but expected values are contrail-route and security-zone.";
         type string;
      }
      leaf allotted-resource-pointer {
         description "Pointer to the allotted-resources topology";
         type string;
      }
   }
   grouping forwarding-path-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses forwarding-path-request-input;
   }
   grouping forwarding-path-request-input {
      container forwarding-path-request-input {
         list forwarding-paths {
            key "forwarding-path-name";
            leaf forwarding-path-name {
               description "Forwarding-path-name from tosca-model. ";
               type string;
               mandatory true;
            }
            uses onap-model-information;
         }
      }
   }
   grouping forwarding-path-information {
      leaf forwarding-path-name {
         description "Fowarding-path name from TOSCA model, or name generated by SDNC";
         type string;
      }
      leaf forwarding-path-type {
         description "Based on MySQL Forwarding_Path tables path_type value from related TOSCA model";
         type enumeration {
            enum "VNF";
            enum "Service";
         }
      }
      uses onap-model-information;
      container service-paths {
         list service-path {
            key "service-path-instance-id";
            uses service-path-information;
         }
      }
   }
   grouping service-path-information {
      leaf service-path-instance-id {
         description "Service path instance ID generated by SDNC. Identifies a service-path-instance within a forwarding-path definition";
         type string;
      }
      leaf service-path-instance-name {
         description "A unique name generated by SDNC ( forwarding-path-name + service-path-instance-id )";
         type string;
      }
      leaf version {
         description "Only one version of the service-path-instance data will be available in MD-SAL.  version will be updated when the service-path-instance is reevaluated ";
         type string;
      }
      list service {
         key "service-instance-id";
         leaf service-instance-id {
            description "service-instance-id of each service-instance in the service-path-instance";
            type string;
         }
         leaf service-path-sequence-id {
            description "e.g. S1S2S3S5seq id=1  S1-S2seq id=2  S2S3seq id=3  S3S5Incremental integer value";
            type uint32;
         }
         container vnfs {
            list vnf {
               key "vnf-instance-id";
               uses vnf-path-information;
            }
         }
      }
   }
   grouping vnf-path-information {
      leaf vnf-instance-id {
         description "VNF instance ID in the path";
         type string;
      }
      leaf vnf-path-sequence-id {
         description "Sequence ID at the VNF instance levele.g.  e.g. V1V2V3V5V6seq id=1  V1-V2seq id=2  V2V3seq id=3  V3V5seq id=4  V5V6incremental integer value.";
         type uint32;
      }
      leaf left-network-name {
         description "Every VNF instance in the path is connected to one or two VNFs.";
         type string;
      }
      leaf left-network-role {
         type string;
      }
      leaf right-network-name {
         type string;
      }
      leaf right-network-role {
         type string;
      }
      container vf-module-instance {
         leaf vf-module-id {
            type string;
         }
         leaf vf-module-name {
            type string;
         }
      }
   }
   grouping forwarding-path-level-oper-status { 
      container forwarding-path-level-oper-status { 
         uses oper-status-data; 
      } 
   }
   grouping configuration-info {
      leaf configuration-id {
         type string;
      }
      leaf configuration-type {
         description "Not an enum, but expected values are port-mirror-configuration, , vlan-network-receptor";
         type string;
      }
      leaf configuration-sub-type {
         description "Not an enum, but expected values are vprobe and pprobe";
         type string;
      }
      leaf configuration-topology-link {
         description "Pointer to the configurations topology";
         type string;
      }
   }
   grouping vnfc-instance-group {
      list vnfc-instance-group {
         key "instance-group-role nfc-naming-code configuration-id";
         leaf instance-group-role {
            description "i.e.TSBC_VNFC_group";
            type string;
            mandatory true;
         }
         leaf nfc-naming-code {
            description "Set to nfc-naming-code from A&AI";
            type string;
            mandatory true;
         }
         leaf configuration-id {
            type string;
            mandatory true;
         }
         leaf group-type {
            description " port-mirror-source or  port-mirror-dest";
            type string;
         }
         uses vnfc-objects;
      }
   }
   grouping vnfc-objects {
      container vnfc-objects {
         list vnfc-object {
            key "vnfc-key";
            leaf vnfc-key {
               type string;
            }
            leaf vnfc-name {
               description "Vnfc name as key in A&AI";
               type string;
            }
            leaf vm-type {
               type string;
            }
            leaf vnf-id {
               type string;
            }
            leaf vserver-name {
               type string;
            }
            leaf vserver-id {
               type string;
            }
            container vnics {
               list vnic {
                  key "vnic-port-name";
                  leaf vnic-port-name {
                     type string;
                  }
                  leaf vnic-port-id {
                     type string;
                  }
                  container capacity {
                     leaf vnic-capacity {
                        type uint32;
                     }
                     leaf used-capacity {
                        description "Updated for destination port when source port is mapped/unmapped.";
                        type uint32;
                     }
                  }
                  container vnic-ip-addresses {
                     uses ip-addresses;
                  }
               }
            }
         }
      }
   }
   grouping vnfcs {
      container vnfcs {
         list vnfc {
            key "vnfc-name";
            leaf vnfc-name {
               description "Vnfc name as key in A&AI";
               type string;
            }
            leaf vserver-name {
               type string;
            }
            leaf vserver-id {
               type string;
            }
            uses vnics;
         }
      }
   }
   grouping vnics {
      container vnics {
         list vnic {
            key "vnic-port-name";
            leaf vnic-port-name {
               type string;
            }
            leaf vnic-port-id {
               type string;
            }
            uses sub-interfaces;
         }
      }
   }
   grouping sub-interfaces {
      container sub-interfaces {
         list sub-interface {
            key "sub-interface-port-name";
            leaf sub-interface-port-name {
               type string;
            }
            leaf sub-interface-port-id {
               type string;
            }
            container sub-interface-ip-addresses {
               uses ip-addresses;
            }
            uses vlan-tags;
            container sub-interface-network {
               leaf network-name {
                  type string;
               }
               leaf network-id {
                  type string;
               }
            }
            leaf sub-interface-status {
               description "NULL, unassigned, assigned";
               type string;
            }
         }
      }
   }
   grouping vlan-tags {
      container vlan-tags {
         leaf vlan-interface {
            description "A&AI Key";
            type string;
         }
         leaf upper-tag-id {
            type uint32;
         }
         leaf lower-tag-id {
            type uint32;
         }
         leaf is-private {
            type boolean;
         }
      }
   }
   grouping vlan-vnfc-instance-groups {
      container vlan-vnfc-instance-groups {
         list vlan-vnfc-instance-group {
            key "instance-group-id";
            leaf instance-group-id {
               description "A&AI ID";
               type string;
               mandatory true;
            }
            leaf instance-group-function {
               type string;
            }
            leaf vnf-id {
               type string;
            }
            container vnfcs {
               list vnfc {
                  key "vnfc-name";
                  leaf vnfc-name {
                     type string;
                  }
                  uses vnic-groups;
               }
            }
         }
      }
   }
   grouping vnic-groups {
      container vnic-groups {
         list vnic-group {
            key "vnic-interface-role";
            leaf vnic-interface-role {
               description "Same as network-role of network where vnic is connected";
               type string;
               mandatory true;
            }
            leaf network-instance-group-function {
               description "network-instance-Group-function for network collection where vnics with vnic-interface-role will connect";
               type string;
            } 
            leaf vlan-assignment-policy-name {
               description "Policy name in ASDC model & policy definition in Policy Engine";
               type string;
            }
            leaf vlan-tag-index-next {
               description "Next tag to be assigned";
               type uint32;
            }
            container vlan-common-ip-addresses {
               uses ip-addresses;
            }
            container vlan-vnics {
               list vlan-vnic {
                  key "vnic-port-id";
                  leaf vnic-port-id {
                     type string;
                     mandatory true;
                  }
                  container vnic-sub-interfaces {
                     uses sub-interface-network-data;
                  }
               }
            }
         }
      }
   }
   grouping vnf-network-collection {
      list vnf-network-collection {
         key "network-instance-group-function";
         leaf network-instance-group-function {
            description "Network Instance-Group function in A&AI";
            type string;
            mandatory true;
         }
         leaf network-instance-group-id {
            description "Network Instance-Group id in A&AI";
            type string;
         }
         leaf network-collection-service-instance-id {
            description "Service-instance-id of service that created the network collection";
            type string;
         }
         leaf network-collection-customization-uuid {
            description "network-collection-customization-uuid stored in Network IsntanceGroup.customization-uuid in A&AI";
            type string;
         }
         container networks {
            list network {
               key "network-id";
               leaf network-id {
                  description "Index into network-topology-identifier structure";
                  type string;
                  mandatory true;
               }
               leaf neutron-network-id {
                  description "Neutron-network-id assigned by PO/RO";
                  type string;
               }
            }
         }
         container vnf-floating-ip {
            uses ip-addresses;
         }
      }
   }
   grouping vnf-sub-interface-group {
      list vnf-sub-interface-group {
         key "vnfc-instance-group-function network-instance-group-function parent-port-role";
         leaf vnfc-instance-group-function {
            type string;
            mandatory true;
         }
         leaf network-instance-group-function {
            type string;
            mandatory true;
         }
         leaf parent-port-role {
            type string;
            mandatory true;
         }
         uses vnfcs;
         container customer-bonding-requests {
            list customer-bonding-request {
               key "configuration-id";
               leaf configuration-id {
                  description "e.g. vlan network receptor configuration id";
                  type string;
               }
            }
         }
      }
   }
   grouping sub-interface-network-data {
      list sub-interface-network-data {
         key "network-id";
         leaf network-id {
            description "Subinterface network id (UUID in A&AI)";
            type string;
            mandatory true;
         }
         leaf neutron-network-id {
            description "Neutron network id assigned by PO/RP";
            type string;
         }
         leaf network-name {
            description "Subinterface network name";
            type uint32;
         }
         leaf vlan-tag-id {
            description "Vlan tag assigned to subinterface port";
            type uint32;
         }
         leaf network-role {
            description "e.g. untrusted ";
            type string;
         }
         leaf network-role-tag {
            description "Assuming HEAT template network role tag parameter - not used";
            type string;
         }
         container network-information-items {
            list network-information-item {
               key "ip-version";
               leaf ip-version {
                  description "Use ipv4 or ipv6";
                  type string;
               }
               leaf use-dhcp {
                  description "Indicator to use DHCP on this network for this VM - set to N for Vlan tagging";
                  type enumeration {
                     enum "Y";
                     enum "N";
                  }
               }
               leaf ip-count {
                  description "The number of ip addresses to be assigned per vm for this network role";
                  type uint8;
               }
               container network-ips {
                  leaf-list network-ip {
                     description "List of assigned ip addresses of type ip-version on a network.";
                     type inet:ip-address;
                     ordered-by user;
                  }
               }
            }
         }
         container floating-ips {
            leaf-list floating-ip-v4 {
               description "Floating ipv4 for VMs of a given type on this network";
               type inet:ip-address;
               ordered-by user;
            }
            leaf-list floating-ip-v6 {
               description "Floating ipv6 for VMs of a given type on this network";
               type inet:ipv6-address;
               ordered-by user;
            }
         }
      }
   }
   grouping vnf-cloud-param {
      leaf service-instance-id {
         type string;
      }
      leaf service-instance-name {
         type string;
      }
      list vnf {
         key "vnf-id";
         leaf vnf-id {
            type string;
         }
         leaf vnf-name {
            type string;
         }
         uses param;
         list vf-module {
            key "vf-module-id";
            leaf vf-module-id {
               type string;
            }
            uses param;
         }
      }
   }
   grouping vnf-get-resource-request-input-data {
      list vnf {
         key "vnf-id";
         leaf vnf-id {
            type string;
         }
         list vf-module {
            key "vf-module-id";
            leaf vf-module-id {
               type string;
            }
         }
      }
   }
   grouping license-information {
      container license-information {
         list entitlement-pool-list {
            key "entitlement-pool-uuid action";
            leaf entitlement-pool-uuid {
               type string;
               mandatory true;
            }
            leaf action {
               type string;
               mandatory true;
            }
            leaf entitlement-pool-invariant-uuid {
               type string;
            }
            leaf entitlement-uuid {
               description "assigned by ALTS";
               type string;
            }
         }
         list license-key-group-list {
            key "license-key-group-uuid action";
            leaf license-key-group-uuid {
               type string;
               mandatory true;
            }
            leaf action {
               type string;
               mandatory true;
            }
            leaf license-key-group-invariant-uuid {
               type string;
            }
            leaf license-key {
               description "assigned by ALTS";
               type string;
            }
            leaf license-uuid {
               description "assigned by ALTS";
               type string;
            }
         }
      }
   }
   grouping related-network {
      list related-network {
         key "network-id";
         leaf network-id {
            description "Key to l3-network object";
            type string;
         }
         leaf network-role {
            type string;
         }
         uses vlan-tags;
      }
   }
   grouping connection-point {
      container connection-point {
         leaf connection-point-id {
            description "Key to CP object in A&AI";
            type string;
         }
         leaf port-id {
            description "port-index when multiple CPs connect to same network. Default zero (0)";
            type string;
         }
         list vlan-data {
            key "vlan-uuid";
            leaf vlan-uuid {
               description "Key to vlan-tag uuid object in A&AI Generated by vlan mS";
               type string;
            }
            leaf vlan-tag-id {
               type string;
            }
            leaf vlan-tag-description {
               type string;
            }
            leaf vlan-role {
               description "Inner/Outer roles";
               type string;
            }
         }
      }
   }
   grouping aggregate-routes {
      list aggregate-routes {
         key "route-id";
         leaf route-id {
            description "Unique id";
            type string;
         }
         leaf start-address {
            type inet:ip-address;
         }
         leaf cidr-mask {
            type string;
         }
         leaf ip-version {
            description "Use values 4 or 6.";
            type string;
         }
      }
   }
   grouping pnf-information {
      container pnf-information {
         leaf pnf-name {
            description "Key for A&AI query";
            type string;
         }
         leaf pnf-type {
            type string;
         }
         uses onap-model-information;
      }
   }
   grouping contrail-route-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses allotted-resource-information;
      uses contrail-route-request-input;
   }
   grouping contrail-route-request-input {
      container contrail-route-request-input {
         container source-network {
            uses network-info;
         }
         container dest-network {
            uses network-info;
         }
         container contrail-applied-service-info {
            leaf service-instance-id {
               description "The service-instance-id of the service in which the resource(s) providing the applied-service are. For vIPR, this is the service-instance-id of the vIPR-ATM service in which the vIPR-ATM VNF Contrail service is the applied service. MSO will populate with the input data.";
               type string;
            }
            leaf contrail-fqdn {
               description "For future use by MSO on input; MSO not expected to populate in 1707. If MSO can identify the contrail-fqdn of the Contrail applied service for this contrail-route, then it would be specified here on input. Otherwise, SDN-C will look it up by the vIPR-ATM VNF in the service-instance-id of the contrail-applied-service-info grouing.";
               type string;
            }
         }
         container contrail-route-input-parameters {
            uses param;
         }
      }
   }
   grouping network-info {
      leaf network-id {
         type string;
      }
      leaf network-role {
         type string;
      }
   }
   grouping contrail-route-topology {
      container contrail-route-topology {
         uses allotted-resource-identifiers;
         uses onap-model-information;
         uses contrail-route-assignments;
         container contrail-route-parameters {
            uses param;
         }
      }
   }
   grouping contrail-route-assignments {
      container contrail-route-assignments {
         leaf fq-name {
            description "The Contrail fq-name of the network policy";
            type string;
         }
         leaf contrail-id {
            description "The ID assigned by Contrail to the network-policy (one for one with the fq-name)";
            type string;
         }
         container source-network {
            uses network-info;
         }
         container dest-network {
            uses network-info;
         }
         container contrail-applied-service {
            leaf service-instance-id {
               description "The service-instance-id of the vnf from which the contrail applied service is coming";
               type string;
            }
            leaf vnf-id {
               description "The vnf representing the contrail applied service";
               type string;
            }
            leaf contrail-fqdn {
               description "This is the fq-name of the Contrail service instance through which the route is passing.";
               type string;
            }
         }
         leaf vlan-tag {
            description "Contrail-assigned vlan-tag to the vipr vm interface for this route.";
            type string;
         }
      }
   }
   grouping security-zone-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses allotted-resource-information;
      uses security-zone-request-input;
   }
   grouping security-zone-request-input {
      container security-zone-request-input {
         leaf vlan-tag {
            type string;
         }
         leaf trusted-network-role {
            description "In the case of vIPR, this is the landing networks network-role; used in naming";
            type string;
         }
         leaf untrusted-network-role {
            description "In the case of vIPR, this is the tenant oam networks network-role; used in naming";
            type string;
         }
         container security-zone-input-parameters {
            uses param;
         }
      }
   }
   grouping security-zone-topology {
      container security-zone-topology {
         uses allotted-resource-identifiers;
         uses onap-model-information;
         uses security-zone-assignments;
         container security-zone-parameters {
            uses param;
         }
      }
   }
   grouping security-zone-assignments {
      container security-zone-assignments {
         leaf trusted-network-role {
            description "In the case of vIPR, this is the landing networks network-role; used in naming";
            type string;
         }
         leaf security-zone-name-trusted {
            type string;
         }
         leaf untrusted-network-role {
            description "In the case of vIPR, this is the tenant oam networks network-role; used in naming";
            type string;
         }
         leaf security-zone-name-untrusted {
            type string;
         }
         leaf security-zone-service-instance-id {
            description "Will be the same as the parent-service-instance-id";
            type string;
         }
         leaf security-zone-vnf-id {
            description "Selected by SDNC from the security-zone-service-instance-id";
            type string;
         }
         leaf vlan-tag {
            type string;
         }
      }
   }
   grouping port-mirror-topology-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses configuration-information;
      uses port-mirror-configuration-request-input;
   }
   grouping port-mirror-configuration-request-input {
      container port-mirror-configuration-request-input {
         container source-port {
            uses port-info;
            leaf source-port-id {
               description "needed for srv-action=disable/enable";
               type string;
            }
         }
         container dest-port {
            uses port-info;
         }
         uses region-identifier;
         container port-mirror-configuration-input-parameters {
            uses param;
         }
      }
   }
   grouping port-info {
      leaf service-instance-id {
         description "May not be need.";
         type string;
      }
      uses pnf-information;
      uses vnf-information;
   }
   grouping port-mirror-configuration-topology {
      container port-mirror-configuration-topology {
         uses configuration-identifiers;
         uses onap-model-information;
         uses port-mirror-configuration-assignments;
         container port-mirror-configuration-parameters {
            uses param;
         }
      }
   }
   grouping port-mirror-configuration-assignments {
      container port-mirror-configuration-assignments {
         container contrail-vmi-params {
            uses param;
         }
         leaf vnics-group-id {
            type string;
         }
         leaf owning-entity {
            type string;
         }
         leaf tenant-context {
            description "From tenant object in A&AI";
            type string;
         }
         leaf tenant {
            description "Tenant name from A&AI for source VNF";
            type string;
         }
         leaf tenant-id {
            description "tenant-id from A&AI for source VNF";
            type string;
         }
         leaf dest-tenant {
            description "Tenant name from A&AI for destination VNF";
            type string;
         }
         leaf dest-tenant-id {
            description "tenant-id from A&AI for destination VNF";
            type string;
         }
         leaf cloud-region-id {
            type string;
         }
         leaf cloud-owner {
            type string;
         }
         leaf dest-network-fqdn {
            type string;
         }
         leaf source-network-fqdn {
            type string;
         }
         leaf source-capacity {
            description "Source port pps (packets per second) rating from tosca model";
            type uint32;
         }
         leaf source-vnf-id {
            type string;
         }
         leaf dest-vnf-id {
            description "For vProbe";
            type string;
         }
         leaf dest-pnf-name {
            description "For pProbe";
            type string;
         }
         leaf dest-p-interface {
            description "For pProbe; from policy manager";
            type string;
         }
         leaf dest-pnf-port-policy-name {
            description "For pProbe; from tosca model";
            type string;
         }
         leaf probe-type {
            description "vprobe or pprobe; derived from configuration-information.configuration-sub-type";
            type string;
         }
         leaf route-allotted-resource-id {
            description "For vProbe";
            type string;
         }
         container source-vnfc-instance-group-id {
            leaf service-instance-id {
               type string;
            }
            leaf nfc-naming-code {
               type string;
            }
            leaf instance-group-role {
               type string;
            }
            leaf configuration-id {
               type string;
            }
         }
         container dest-vnfc-instance-group-id {
            leaf service-instance-id {
               type string;
            }
            leaf nfc-naming-code {
               type string;
            }
            leaf instance-group-role {
               type string;
            }
            leaf configuration-id {
               type string;
            }
         }
         container source-to-dest-maps {
            list source-to-dest-map {
               key "source-port-id";
               leaf source-port-id {
                  type string;
                  mandatory true;
               }
               leaf source-port-name {
                  type string;
               }
               leaf source-vserver-id {
                  type string;
               }
               leaf dest-vserver-id {
                  type string;
               }
               leaf dest-port-id {
                  type string;
               }
               leaf dest-port-name {
                  type string;
               }
               leaf link-name {
                  type string;
               }
               container dest-ip-addresses {
                  uses ip-addresses;
               }
            }
         }
      }
   }
   grouping gc-topology-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses configuration-information;
      uses gc-request-input;
   }
   grouping gc-request-input {
      container gc-request-input {
         leaf vnf-id {
            type string;
         }
         leaf vf-module-id {
            description "This is mandatory in case of rebuild";
            type string;
         }
         container input-parameters {
            uses param;
         }
         leaf rebuild {
            description "Value will indicate what to rebuild";
            type string;
         }
         list configuration-ids {
            key "configuration-id";
            leaf configuration-id {
               type string;
            }
         }
      }
   }
   grouping vnr-parameters {
      container vnr-parameters {
         leaf vnf-id {
            type string;
         }
         leaf vf-module-id {
            description "This is mandatory in case of rebuild";
            type string;
         }
         leaf vnf-service-instance-id {
            type string;
         }
         leaf network-collection-service-instance-id {
            description "service instance id that created network-collection";
            type string;
         }
         leaf network-instance-group-id {
            type string;
         }
         leaf network-id {
            type string;
         }
         leaf vnfc-instance-group-function {
            type string;
         }
         leaf network-instance-group-function {
            type string;
         }
         leaf parent-port-role {
            type string;
         }
         leaf upper-tag-id {
            type uint32;
         }
         leaf lower-tag-id {
            type uint32;
         }
      }
   }
   grouping tunnelxconn-operation-information {
       uses sdnc-request-header;
       uses request-information;
       uses service-information;
       uses allotted-resource-information;
       uses tunnelxconn-request-input;
   }
   grouping tunnelxconn-request-input {

       container tunnelxconn-request-input {
           leaf brg-wan-mac-address {
               type string;
           }
       }
   }
   grouping tunnelxconn-topology {
       container tunnelxconn-topology {
           uses allotted-resource-identifiers;
           uses onap-model-information;
           uses tunnelxconn-assignments;
           container tunnelxconn-parameters {
               uses param;
           }
       }
   }
   grouping tunnelxconn-assignments {
	   container tunnelxconn-assignments {
	       leaf vni {
	           description "The Network Controller will assign a VNI value from the associated vGMUX VNI pool";
	           type string;
	       }
	       leaf vgmux-bearer-ip {
	           description "The Network Controller will look up the vgmux bearer ip from the vgmux vf module";
	           type inet:ip-address;
	       }
	       leaf vgmux-lan-ip {
	           description "The Network Controller will look up the vgmux lan ip from the vgmux vg module";
	           type inet:ip-address;
	       }
	       leaf vg-ip {
	           description "The Network Controller will assign the VG IP address from local inventory";
	           type inet:ip-address;
	       }
	   }
   }
   grouping brg-operation-information {
       uses sdnc-request-header;
       uses request-information;
       uses service-information;
       uses allotted-resource-information;
       uses brg-request-input;
   }
   grouping brg-request-input {
       container brg-request-input {
           leaf vgmux-bearer-ip {
               type inet:ip-address;
           }
           leaf vni {
               type string;
           }
           leaf brg-wan-mac-address {
               type string;
           }
       }
   }
   grouping brg-topology {
       container brg-topology {
           uses allotted-resource-identifiers;
           uses onap-model-information;
           uses brg-assignments;
           container brg-parameters {
               uses param;
           }
       }
   }
   grouping brg-assignments {
	   container brg-assignments {
	       leaf vbrg-wan-ip {
	           type inet:ip-address;
	       }
	   }
   }
   grouping connection-attachment-operation-information {
      uses sdnc-request-header;
      uses request-information;
      uses service-information;
      uses allotted-resource-information;
      uses connection-attachment-request-input;
   }

   grouping connection-attachment-request-input {
      container connection-attachment-request-input {
         uses param;
      }
   }

   grouping connection-attachment-topology {
      container connection-attachment-topology {
         uses allotted-resource-identifiers;
         uses onap-model-information;
         uses connection-attachment-assignments;
         container connection-attachment-parameters {
            uses param;
         }
      }
   }

   grouping connection-attachment-assignments {
      container connection-attachment-assignments {
      }
   }

   grouping vnf-vnr-rebuild-data {
      container vnf-vnr-rebuild-data {
         leaf vnf-id {
            type string;
         }
         leaf vnf-service-instance-id {
            type string;
         }
         list vnrs-data {
            key "configuration-id";
            leaf configuration-id {
               type string;
            }
            leaf network-instance-group-id {
               type string;
            }
            leaf network-id {
               type string;
            }
            leaf vnfc-instance-group-function {
               type string;
            }
            leaf network-instance-group-function {
               type string;
            }
            leaf parent-port-role {
               type string;
            }
            leaf upper-tag-id {
               type uint32;
            }
            leaf lower-tag-id {
               type uint32;
            }
         }
      }
   }
   grouping allotted-resource-information {
      container allotted-resource-information {
         leaf allotted-resource-id {
            type string;
         }
         leaf allotted-resource-type {
            description "Not an enum, but expected values are contrail-route and security-zone.";
            type string;
         }
         leaf parent-service-instance-id {
            description "Service-instance-id of the parent service to which this allotted resource belongs.";
            type string;
         }
         uses onap-model-information;
      }
   }
   grouping allotted-resource-identifiers {
      container allotted-resource-identifiers {
         leaf allotted-resource-id {
            type string;
         }
         leaf allotted-resource-name {
            description "For a contrail-route, the network policy name.";
            type string;
         }
         leaf allotted-resource-type {
            description "(Added in draft 32)Expected to be contrail-route or security-zone.";
            type string;
         }
         leaf consuming-service-instance-id {
            description "The service-instance-id of the consuming service of this allotted resource";
            type string;
         }
         leaf parent-service-instance-id {
            description "Service-instance-id of the parent service to which this allotted resource belongs.";
            type string;
         }
      }
   }
   grouping allotted-resource-oper-status {
      container allotted-resource-oper-status {
         uses oper-status-data;
      }
   }
   grouping allotted-resource-status {
      container allotted-resource-status {
         leaf response-code {
            type string;
         }
         leaf response-message {
            type string;
         }
         leaf final-indicator {
            type string;
         }
         leaf request-status {
            type enumeration {
               enum "synccomplete";
               enum "asynccomplete";
               enum "notifycomplete";
            }
         }
         leaf action {
            description "value would one of possible request-actions; match the list in service-data oper-status";
            type string;
         }
         leaf rpc-name {
            type string;
         }
         leaf rpc-action {
            description "this is the svc-action from the incoming request";
            type enumeration {
               enum "assign";
               enum "activate";
               enum "create";
               enum "delete";
               enum "unassign";
               enum "deactivate";
            }
         }
         leaf response-timestamp {
            type string;
         }
      }
   }
   grouping configuration-information {
      container configuration-information {
         leaf configuration-id {
            type string;
         }
         leaf configuration-name {
            type string;
         }
         leaf configuration-type {
            description "Not an enum, but expected values are port-mirror-configuration, vlan-network-receptor";
            type string;
         }
         leaf configuration-sub-type {
            description "e.g. vprobe and pprobe when configuration-type=port-mirror-configuration";
            type string;
         }
         uses onap-model-information;
      }
   }
   grouping configuration-identifiers {
      container configuration-identifiers {
         leaf configuration-id {
            type string;
         }
         leaf configuration-name {
            type string;
         }
         leaf configuration-type {
            description "Not an enum, but expected values are port-mirror-configuration.";
            type string;
         }
         leaf configuration-sub-type {
            description " vprobe and pprobe";
            type string;
         }
         leaf parent-service-instance-id {
            description "Service-instance-id of the parent service to which this resource belongs.";
            type string;
         }
      }
   }
   grouping configuration-oper-status {
      container configuration-oper-status {
         uses oper-status-data;
      }
   }
   grouping configuration-status {
      container configuration-status {
         leaf response-code {
            type string;
         }
         leaf response-message {
            type string;
         }
         leaf final-indicator {
            type string;
         }
         leaf request-status {
            type enumeration {
               enum "synccomplete";
               enum "asynccomplete";
               enum "notifycomplete";
            }
         }
         leaf action {
            description "value would one of possible request-actions; match the list in service-data oper-status";
            type string;
         }
         leaf rpc-name {
            type string;
         }
         leaf rpc-action {
            description "this is the svc-action from the incoming request";
            type enumeration {
               enum "assign";
               enum "activate";
               enum "create";
               enum "disable";
               enum "enable";
               enum "delete";
               enum "unassign";
               enum "deactivate";
            }
         }
         leaf response-timestamp {
            type string;
         }
      }
   }
   grouping topology-response-common {
      leaf svc-request-id {
         description "the request id from the request message for which this is the responseKeep as M";
         type string;
      }
      leaf response-code {
         description "a success code or an defined error codeKeep as M";
         type string;
      }
      leaf response-message {
         description "message included for error code";
         type string;
      }
      leaf ack-final-indicator {
         description "Expected to be Y or N.";
         type string;
      }
   }
   grouping sdnc-request-header {
      container sdnc-request-header {
         leaf svc-request-id {
            description "Uniquely generated by calling system (e.g. MSO or SDN-GP)";
            type string;
         }
         leaf svc-action {
            description "This is the rpcAction";
            type enumeration {
               enum "reserve";
               enum "assign";
               enum "activate";
               enum "delete";
               enum "changeassign";
               enum "changedelete";
               enum "rollback";
               enum "deactivate";
               enum "unassign";
               enum "create";
               enum "disable";
               enum "enable";
               enum "update";
               enum "reoptimize";
               enum "rebuild";
            }
         }
         leaf svc-notification-url {
            description "Contains URL for asynchronous response";
            type string;
         }
      }
   }
   grouping request-information {
      container request-information {
         leaf request-id {
            description "Request ID generated upstream of MSO";
            type string;
         }
         leaf request-action {
            description "still need to work Disconnect";
            type enumeration {
               enum "CreateNetworkInstance";
               enum "ActivateNetworkInstance";
               enum "DeActivateNetworkInstance";
               enum "CreateServiceInstance";
               enum "DeleteServiceInstance";
               enum "DeleteNetworkInstance";
               enum "CreateVnfInstance";
               enum "ActivateVnfInstance";
               enum "DeleteVnfInstance";
               enum "CreateVfModuleInstance";
               enum "ActivateVfModuleInstance";
               enum "DeleteVfModuleInstance";
               enum "CreateContrailRouteInstance";
               enum "DeleteContrailRouteInstance";
               enum "CreateSecurityZoneInstance";
               enum "DeleteSecurityZoneInstance";
               enum "ActivateDCINetworkInstance";
               enum "DeActivateDCINetworkInstance";
               enum "CreateTunnelXConnInstance";
               enum "DeleteTunnelXConnInstance";
               enum "CreateBRGInstance";
               enum "DeleteBRGInstance";
               enum "CreateSOTNConnectivityInstance";
               enum "ActivateSOTNConnectivityInstance";
               enum "DeactivateSOTNConnectivityInstance";
               enum "DeleteSOTNConnectivityInstance";
               enum "CreateSOTNAttachmentInstance";
               enum "ActivateSOTNAttachmentInstance";
               enum "DeactivateSOTNAttachmentInstance";
               enum "DeleteSOTNAttachmentInstance";
               enum "CreateSiteInstance";
               enum "ActivateSiteInstance";
               enum "DeactivateSiteInstance";
               enum "DeleteSiteInstance";
               enum "CreatePortMirrorConfigurationInstance";
               enum "DeletePortMirrorConfigurationInstance";
               enum "ChangePortMirrorConfigurationInstance";
               enum "CreateGenericConfigurationInstance";
               enum "RebuildGenericConfigurationInstance";
               enum "DeleteGenericConfigurationInstance";
               enum "PreloadVfModuleRequest";
               enum "DeletePreloadVfModuleRequest";
               enum "PreloadNetworkRequest";
               enum "DeletePreloadNetworkRequest";
               enum "CreateForwardingPathInstance";
               enum "DeleteForwardingPathInstance";
               enum "UpdateForwardingPathInstance";
               enum "CreateSDWANConnectivityInstance";
               enum "ActivateSDWANConnectivityInstance";
               enum "DeactivateSDWANConnectivityInstance";
               enum "DeleteSDWANConnectivityInstance";
               enum "CreateSDWANDeviceInstance";
               enum "ActivateSDWANDeviceInstance";
               enum "DeactivateSDWANDeviceInstance";
               enum "DeleteSDWANDeviceInstance";
               enum "CreateSDWANPortInstance";
               enum "ActivateSDWANPortInstance";
               enum "DeactivateSDWANPortInstance";
               enum "DeleteSDWANPortInstance";
               enum "CreateSDWANAttachmentInstance";
               enum "ActivateSDWANAttachmentInstance";
               enum "DeactivateSDWANAttachmentInstance";
               enum "DeleteSDWANAttachmentInstance";
               enum "ReoptimizeSOTNInstance";
            }
         }
         leaf source {
            type string;
         }
         leaf notification-url {
            type string;
         }
         leaf order-number {
            type string;
         }
         leaf order-version {
            type string;
         }
      }
   }
   grouping service-information {
      container service-information {
         leaf service-id {
            description "This maps to the product-family-id in A&AI";
            type string;
         }
         leaf subscription-service-type {
            description "used to reference a&ai subscription-service-type. For example, we show as vIPR-ATM in example.";
            type string;
         }
         uses onap-model-information;
         leaf service-instance-id {
            type string;
         }
         leaf global-customer-id {
            description "need for put of data to AnAI (MSO provides)";
            type string;
         }
         leaf subscriber-name {
            description "Would not be expected for vIPR-ATM or mobility services.";
            type string;
         }
      }
   }
   grouping onap-model-information {
      container onap-model-information {
         leaf model-invariant-uuid {
            description "identifies the invariant uuid for this service or resource";
            type string;
         }
         leaf model-customization-uuid {
            description "customized resource for use within a given service.Would not be present at the service level but would be present for the resource level";
            type string;
         }
         leaf model-uuid {
            description "identifies the uuid for this service or resource, which is version specific";
            type string;
         }
         leaf model-version {
            type string;
         }
         leaf model-name {
            type string;
         }
      }
   }
   grouping region-identifier {
      leaf tenant {
         type string;
      }
      leaf aic-cloud-region {
         description "The AIC cloud region which maps to contrail versions";
         type string;
      }
      leaf cloud-owner {
         description "The cloud owner provided by the caller";
         type string;
      }
      leaf aic-clli {
         description "Not expected to be used";
         type string;
      }
   }
   grouping param {
      list param {
         key "name";
         leaf name {
            type string;
         }
         leaf value {
            type string;
         }
         container resource-resolution-data {
            list resource-key {
               key "name";
               leaf name {
                  type string;
               }
               leaf value {
                  type string;
               }
            }
            leaf status {
               description "SUCCESS, FAILED, or PENDING - RA returned data as capability";
               type string;
            }
            leaf capability-name {
               description "Resource assignment resolution Capability name";
               type string;
            }
         }
      }
   }
   grouping ip-addresses {
      container ip-addresses {
         leaf ipv4-address {
            type inet:ip-address;
         }
         leaf ipv6-address {
            type inet:ip-address;
         }
         leaf vipv4-address {
            description "Virtual v4";
            type inet:ip-address;
         }
         leaf vipv6-address {
            description "Virtual v6";
            type inet:ip-address;
         }
      }
   }
   grouping instance-reference {
      leaf instance-id {
         type string;
      }
      leaf object-path {
         description "restconf retrieval path to this particular objectE.g. restconf/config/GENERIC-RESOURCE-API:services/service/$service-instance-id/service-data/service-topology/";
         type string;
      }
   }
   grouping oper-status-data {
      leaf order-status {
         description "TBD - do we need Request failed statuses? RequestFailed | InProgressTimeout";
         type enumeration {
            enum "Active";
            enum "PendingAssignment";
            enum "PendingCreate";
            enum "PendingUpdate";
            enum "PendingDelete";
            enum "Deleted";
            enum "Created";
         }
      }
      leaf last-rpc-action {
         type enumeration {
            enum "assign";
            enum "activate";
            enum "delete";
            enum "unassign";
            enum "deactivate";
            enum "create";
            enum "changeassign";
            enum "reoptimize";
         }
      }
      leaf last-action {
         description "should be list of possible request-actions";
         type enumeration {
            enum "CreateNetworkInstance";
            enum "ActivateNetworkInstance";
            enum "DeActivateNetworkInstance";
            enum "CreateServiceInstance";
            enum "DeleteServiceInstance";
            enum "DeleteNetworkInstance";
            enum "CreateVnfInstance";
            enum "ActivateVnfInstance";
            enum "DeleteVnfInstance";
            enum "CreateVfModuleInstance";
            enum "ActivateVfModuleInstance";
            enum "DeleteVfModuleInstance";
            enum "CreateContrailRouteInstance";
            enum "DeleteContrailRouteInstance";
            enum "CreateSecurityZoneInstance";
            enum "DeleteSecurityZoneInstance";
            enum "ActivateDCINetworkInstance";
            enum "DeActivateDCINetworkInstance";
            enum "CreateTunnelXConnInstance";
            enum "DeleteTunnelXConnInstance";
            enum "CreateBRGInstance";
            enum "DeleteBRGInstance";
            enum "CreateSOTNConnectivityInstance";
            enum "ActivateSOTNConnectivityInstance";
            enum "DeactivateSOTNConnectivityInstance";
            enum "DeleteSOTNConnectivityInstance";
            enum "CreateSOTNAttachmentInstance";
            enum "ActivateSOTNAttachmentInstance";
            enum "DeactivateSOTNAttachmentInstance";
            enum "DeleteSOTNAttachmentInstance";
            enum "CreateSiteInstance";
            enum "ActivateSiteInstance";
            enum "DeactivateSiteInstance";
            enum "DeleteSiteInstance";
            enum "CreatePortMirrorConfigurationInstance";
            enum "DeletePortMirrorConfigurationInstance";
            enum "ChangePortMirrorConfigurationInstance";
            enum "CreateGenericConfigurationInstance";
            enum "DeleteGenericConfigurationInstance";
            enum "PreloadVfModuleRequest";
            enum "DeletePreloadVfModuleRequest";
            enum "PreloadNetworkRequest";
            enum "DeletePreloadNetworkRequest";
            enum "CreateForwardingPathInstance";
            enum "DeleteForwardingPathInstance";
            enum "UpdateForwardingPathInstance";
            enum "CreateSDWANConnectivityInstance";
            enum "ActivateSDWANConnectivityInstance";
            enum "DeactivateSDWANConnectivityInstance";
            enum "DeleteSDWANConnectivityInstance";
            enum "CreateSDWANDeviceInstance";
            enum "ActivateSDWANDeviceInstance";
            enum "DeactivateSDWANDeviceInstance";
            enum "DeleteSDWANDeviceInstance";
            enum "CreateSDWANPortInstance";
            enum "ActivateSDWANPortInstance";
            enum "DeactivateSDWANPortInstance";
            enum "DeleteSDWANPortInstance";
            enum "CreateSDWANAttachmentInstance";
            enum "ActivateSDWANAttachmentInstance";
            enum "DeactivateSDWANAttachmentInstance";
            enum "DeleteSDWANAttachmentInstance";
            enum "ReoptimizeSOTNInstance";
         }
      }
      leaf last-svc-request-id {
         description "Not currently populated in service data.";
         type string;
      }
      leaf last-order-status {
         type enumeration {
            enum "Active";
            enum "PendingAssignment";
            enum "PendingCreate";
            enum "PendingUpdate";
            enum "PendingDelete";
            enum "Deleted";
            enum "Created";
         }
      }
      leaf create-timestamp {
         description "Not currently populated in service data.";
         type string;
      }
      leaf modify-timestamp {
         type string;
      }
   }
   grouping service-response-information {
      container service-response-information {
         uses instance-reference;
      }
   }
   grouping network-response-information {
      container network-response-information {
         uses instance-reference;
      }
   }
   grouping vnf-response-information {
      container vnf-response-information {
         uses instance-reference;
      }
   }
   grouping vf-module-response-information {
      container vf-module-response-information {
         uses instance-reference;
      }
   }
   grouping contrail-route-response-information {
      container contrail-route-response-information {
         uses instance-reference;
      }
   }
   grouping security-zone-response-information {
      container security-zone-response-information {
         uses instance-reference;
      }
   }
   grouping getpathsegment-response-information {
      container getpathsegment-response-information {
         uses instance-reference;
      }
   }
   grouping port-mirror-response-information {
      container port-mirror-response-information {
         uses instance-reference;
      }
   }
   grouping gc-response-information {
      container gc-response-information {
         uses instance-reference;
      }
   }
   grouping tunnelxconn-response-information {
       container tunnelxconn-response-information {
           uses instance-reference;
       }
   }
   grouping brg-response-information {
       container brg-response-information {
           uses instance-reference;
       }
   }
   grouping connection-attachment-response-information {
      container connection-attachment-response-information {
         uses instance-reference;
      }
   }
   grouping preload-model-information {
      list preload-list {
         key "preload-id preload-type";
         leaf preload-id {
            description "vf-module-name or network name";
            type string;
            mandatory true;
         }
         leaf preload-type {
            description "network or vf-module";
            type string;
            mandatory true;
         }
         uses preload-data;
      }
   }
   grouping preload-data {
      container preload-data {
         uses preload-vf-module-topology-information;
         uses preload-network-topology-information;
         uses preload-oper-status;
      }
   }
   grouping preload-vf-module-topology-information {
      container preload-vf-module-topology-information {
         uses vnf-topology-identifier-structure;
         uses vnf-resource-assignments;
         uses vf-module-topology;
      }
   }
   grouping preload-network-topology-information {
      container preload-network-topology-information {
         uses network-topology-identifier-structure;
         uses subnets;
         uses vpn-bindings;
         uses network-policy;
         uses route-table-reference;
         uses host-routes;
         uses provider-network-information;
      }
   }
   grouping subnets {
      list subnets {
         key "start-address";
         leaf start-address {
            type inet:ip-address;
         }
         leaf gateway-address {
            type inet:ip-address;
         }
         leaf cidr-mask {
            type string;
         }
         leaf ip-version {
            type string;
         }
         leaf dhcp-enabled {
            type enumeration {
               enum "Y";
               enum "N";
            }
         }
         leaf dhcp-start-address {
            type string;
         }
         leaf dhcp-end-address {
            type string;
         }
         leaf addr-from-start {
            description "Default is N";
            type enumeration {
               enum "Y";
               enum "N";
            }
         }
         leaf subnet-name {
            type string;
         }
         leaf subnet-role {
            type string;
         }
         leaf subnet-sequence {
            type uint8;
         }
      }
   }
   grouping vpn-bindings {
      list vpn-bindings {
         key "vpn-binding-id";
         leaf vpn-binding-id {
            type string;
         }
         leaf vpn-name {
            type string;
         }
         leaf global-route-target {
            type string;
         }
         leaf route-target-role {
            type string;
         }
         leaf aic-zone {
            description "AIC Zone the route target associated with";
            type string;
         }
      }
   }
   grouping network-policy {
      list network-policy {
         key "network-policy-fqdn";
         leaf network-policy-fqdn {
            type string;
         }
         leaf network-policy-id {
            type string;
         }
      }
   }
   grouping route-table-reference {
      list route-table-reference {
         key "route-table-reference-fqdn";
         leaf route-table-reference-fqdn {
            type string;
            mandatory true;
         }
         leaf route-table-reference-id {
            type string;
         }
      }
   }
   grouping provider-network-information {
      leaf physical-network-name {
         type string;
      }
      leaf is-provider-network {
         type boolean;
      }
      leaf is-shared-network {
         type boolean;
      }
      leaf is-external-network { 
         type boolean;
      }
   }
   grouping host-routes {
      list host-routes {
         key "route-prefix";
         leaf route-prefix {
            type string;
         }
         leaf next-hop {
            description "Could be ip-address or hostname or service-instance";
            type string;
         }
      }
   }
   grouping preload-oper-status {
      container preload-oper-status {
         leaf order-status {
            type enumeration {
               enum "Active";
               enum "PendingAssignment";
               enum "PendingCreate";
               enum "PendingUpdate";
               enum "PendingDelete";
               enum "Deleted";
            }
         }
         leaf last-action {
            type enumeration {
               enum "PreloadVfModuleRequest";
               enum "DeletePreloadVfModuleRequest";
               enum "PreloadNetworkRequest";
               enum "DeletePreloadNetworkRequest";
            }
         }
         leaf last-svc-request-id {
            type string;
         }
         leaf last-order-status {
            type enumeration {
               enum "Active";
               enum "PendingAssignment";
               enum "PendingCreate";
               enum "PendingUpdate";
               enum "PendingDelete";
               enum "Deleted";
            }
         }
         leaf create-timestamp {
            type string;
         }
         leaf modify-timestamp {
            type string;
         }
         leaf maintenance-indicator {
            type enumeration {
               enum "Y";
               enum "N";
            }
         }
      }
   }
   grouping preload-topology-response-body {
      leaf svc-request-id {
         type string;
      }
      leaf response-code {
         type string;
      }
      leaf response-message {
         type string;
      }
      leaf ack-final-indicator {
         type string;
      }
   }
   rpc generic-configuration-notification {
      input {
         uses sdnc-request-header;
         uses request-information;
         uses service-information;
         uses configuration-information;
         uses topology-response-common;
         leaf configuration-topology-link {
            description "Returns URL to generic-configuration-topology ";
            type string;
         }
         uses vnr-parameters;
         uses vnf-vnr-rebuild-data;
      }
   }
   container services {
      uses service-model-infrastructure;
   }
   container contrail-route-allotted-resources {
      list contrail-route-allotted-resource {
         key "allotted-resource-id";
         leaf allotted-resource-id {
            type string;
            mandatory true;
         }
         container allotted-resource-data {
            container allotted-resource-operation-information {
               uses contrail-route-operation-information;
            }
            uses contrail-route-topology;
            uses allotted-resource-oper-status;
         }
         uses allotted-resource-status;
      }
   }
   container security-zone-allotted-resources {
      list security-zone-allotted-resource {
         key "allotted-resource-id";
         leaf allotted-resource-id {
            type string;
            mandatory true;
         }
         container allotted-resource-data {
            container allotted-resource-operation-information {
               uses security-zone-operation-information;
            }
            uses security-zone-topology;
            container security-zone-parameters {
               uses param;
            }
            uses allotted-resource-oper-status;
         }
         uses allotted-resource-status;
      }
   }
   container tunnelxconn-allotted-resources {
       list tunnelxconn-allotted-resource {
           key "allotted-resource-id";
           leaf allotted-resource-id {
               type string;
               mandatory true;
           }
           container allotted-resource-data {
               container allotted-resource-operation-information {
                   uses tunnelxconn-operation-information;
               }
               uses tunnelxconn-topology;
               container tunnelxconn-parameters {
                   uses param;
               }
               uses allotted-resource-oper-status;
           }
           uses allotted-resource-status;
       }
   }
   container brg-allotted-resources {
       list brg-allotted-resource {
           key "allotted-resource-id";
           leaf allotted-resource-id {
               type string;
               mandatory true;
           }
           container allotted-resource-data {
               container allotted-resource-operation-information {
                   uses brg-operation-information;
               }
               uses brg-topology;
               container brg-parameters {
                   uses param;
               }
               uses allotted-resource-oper-status;
           }
           uses allotted-resource-status;
       }
   }
   container connection-attachment-allotted-resources {
      list connection-attachment-allotted-resource {
         key "allotted-resource-id";
         leaf allotted-resource-id {
            type string;
            mandatory true;
         }
         container allotted-resource-data {
            container allotted-resource-operation-information {
               uses connection-attachment-operation-information;
            }
            uses connection-attachment-topology;
            container connection-attachment-parameters {
               uses param;
            }
            uses allotted-resource-oper-status;
         }
         uses allotted-resource-status;
      }
   }
   container port-mirror-configurations {
      list port-mirror-configuration {
         key "configuration-id";
         leaf configuration-id {
            type string;
            mandatory true;
         }
         container configuration-data {
            container configuration-operation-information {
               uses port-mirror-topology-operation-information;
            }
            uses port-mirror-configuration-topology;
            uses configuration-oper-status;
         }
         uses configuration-status;
      }
   }
   container generic-configurations {
      list gc-configuration {
         key "configuration-id";
         leaf configuration-id {
            type string;
            mandatory true;
         }
         container configuration-data {
            container configuration-operation-information {
               uses gc-topology-operation-information;
            }
            uses configuration-oper-status;
         }
         uses configuration-status;
      }
   }
   rpc service-topology-operation {
      input {
         uses service-operation-information;
      }
      output {
         uses topology-response-common;
         uses service-response-information;
      }
   }
   rpc network-topology-operation {
      input {
         uses network-operation-information;
      }
      output {
         uses topology-response-common;
         uses network-response-information;
         uses service-response-information;
      }
   }
   rpc vnf-topology-operation {
      input {
         uses vnf-operation-information;
      }
      output {
         uses topology-response-common;
         uses vnf-response-information;
         uses service-response-information;
      }
   }
   rpc vf-module-topology-operation {
      input {
         uses vf-module-operation-information;
      }
      output {
         uses topology-response-common;
         uses vf-module-response-information;
         uses vnf-response-information;
         uses service-response-information;
      }
   }
   rpc contrail-route-topology-operation {
      input {
         uses contrail-route-operation-information;
      }
      output {
         uses topology-response-common;
         uses contrail-route-response-information;
         uses service-response-information;
      }
   }
   rpc security-zone-topology-operation {
      input {
         uses security-zone-operation-information;
      }
      output {
         uses topology-response-common;
         uses security-zone-response-information;
         uses service-response-information;
      }
   }
   rpc tunnelxconn-topology-operation {
       input {
           uses tunnelxconn-operation-information;
       }
       output {
           uses topology-response-common;
           uses tunnelxconn-response-information;
           uses service-response-information;
       }
   }
   rpc brg-topology-operation {
       input {
           uses brg-operation-information;
       }
       output {
           uses topology-response-common;
           uses brg-response-information;
           uses service-response-information;
       }
   }
   rpc policy-update-notify-operation {
      input {
         leaf policy-name {
            type string;
            mandatory true;
         }
         leaf version-id {
            description "Map JSON versionNo to version-id";
            type string;
            mandatory true;
         }
         leaf update-type {
            type string;
            mandatory true;
         }
      }
      output {
         leaf error-code {
            type string;
         }
         leaf error-msg {
            type string;
         }
      }
   }
   rpc getpathsegment-topology-operation {
      input {
         uses forwarding-path-operation-information;
      }
      output {
         uses topology-response-common;
         uses getpathsegment-response-information;
         uses service-response-information;
      }
   }
   rpc port-mirror-topology-operation {
      input {
         uses port-mirror-topology-operation-information;
      }
      output {
         uses topology-response-common;
         uses port-mirror-response-information;
         uses service-response-information;
      }
   }
   rpc generic-configuration-topology-operation {
      input {
         uses gc-topology-operation-information;
      }
      output {
         uses topology-response-common;
         uses gc-response-information;
         uses service-response-information;
      }
   }
   rpc vnf-get-resource-request {
      input {
         uses sdnc-request-header;
         uses request-information;
         uses service-information;
         uses vnf-get-resource-request-input-data;
      }
      output {
         container vnf-get-resource-response-information {
            uses vnf-cloud-param;
         }
      }
   }
   container preload-information {
      uses preload-model-information;
   }
   rpc preload-vf-module-topology-operation {
      input {
         uses sdnc-request-header;
         uses request-information;
         uses preload-vf-module-topology-information;
      }
      output {
         uses preload-topology-response-body;
      }
   }
   rpc preload-network-topology-operation {
      input {
         uses sdnc-request-header;
         uses request-information;
         uses preload-network-topology-information;
      }
      output {
         uses preload-topology-response-body;
      }
   }

   rpc connection-attachment-topology-operation {
       input {
           uses connection-attachment-operation-information;
       }
       output {
           uses topology-response-common;
           uses connection-attachment-response-information;
           uses service-response-information;
       }
   }

} ////closes the module