((EntityType)typeDefinition).getValue(CAPABILITIES,entityTpl,true);
                if(caps != null) {
                        //?!? getCapabilities defined only for NodeType...
-                       LinkedHashMap<String,CapabilityTypeDef> capabilities = ((NodeType)typeDefinition).getCapabilities();
+                       LinkedHashMap<String,CapabilityTypeDef> capabilities = null;
+                       if(typeDefinition instanceof NodeType){
+                               capabilities = ((NodeType)typeDefinition).getCapabilities();
+                       } else if (typeDefinition instanceof GroupType){
+                               capabilities = ((GroupType)typeDefinition).getCapabilities();
+                       }
                        for(Map.Entry<String,Object> me: caps.entrySet()) {
                                String name = me. getKey();
                                LinkedHashMap<String,Object> props = (LinkedHashMap<String,Object>)me.getValue();
 
 import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
        @SuppressWarnings("unchecked")
        private ArrayList<Policy> _policies() {
                ArrayList<Policy> alPolicies = new ArrayList<>();
-               for(Object po: _tplPolicies()) {
-                       LinkedHashMap<String,Object> policy = (LinkedHashMap<String,Object>)po;
-                       for(Map.Entry<String,Object> me: policy.entrySet()) {
-                               String policyName = me.getKey();
-                               LinkedHashMap<String,Object> policyTpl = (LinkedHashMap<String,Object>)me.getValue();
-                               ArrayList<String> targetList = (ArrayList<String>)policyTpl.get("targets");
-                               //ArrayList<Object> targetObjects = new ArrayList<>();
-                               ArrayList<NodeTemplate> targetNodes = new ArrayList<>();
-                               ArrayList<Object> targetObjects = new ArrayList<>();
-                               ArrayList<Group> targetGroups = new ArrayList<>();
-                               String targetsType = "groups"; 
-                               if(targetList != null && targetList.size() >= 1) {
-                    targetGroups = _getPolicyGroups(targetList);
-                    if(targetGroups == null) {
-                       targetsType = "node_templates";
-                        targetNodes = _getGroupMembers(targetList);
-                        for(NodeTemplate nt: targetNodes) {
-                               targetObjects.add(nt);
-                        }
-                    }
-                    else {
-                       for(Group gr: targetGroups) {
-                               targetObjects.add(gr);
-                       }
-                    }
-                               }
-                Policy policyObj = new Policy(policyName, 
-                                                                         policyTpl,
-                                                     targetObjects, 
-                                                     targetsType,
-                                                     customDefs);
-                alPolicies.add(policyObj);
+               for(Map.Entry<String,Object> me: _tplPolicies().entrySet()) {
+                       String policyName = me.getKey();
+                       LinkedHashMap<String,Object> policyTpl = (LinkedHashMap<String,Object>)me.getValue();
+                       ArrayList<String> targetList = (ArrayList<String>)policyTpl.get("targets");
+                       ArrayList<NodeTemplate> targetNodes = new ArrayList<>();
+                       ArrayList<Object> targetObjects = new ArrayList<>();
+                       ArrayList<Group> targetGroups = new ArrayList<>();
+                       String targetsType = "groups"; 
+                       if(targetList != null && targetList.size() >= 1) {
+                   targetGroups = _getPolicyGroups(targetList);
+                   if(targetGroups == null || targetGroups.isEmpty()) {
+                       targetsType = "node_templates";
+                       targetNodes = _getGroupMembers(targetList);
+                       for(NodeTemplate nt: targetNodes) {
+                               targetObjects.add(nt);
+                       }
+                   }
+                   else {
+                       for(Group gr: targetGroups) {
+                               targetObjects.add(gr);
+                       }
+                   }
                        }
+               Policy policyObj = new Policy(policyName, 
+                                                                         policyTpl,
+                                             targetObjects, 
+                                             targetsType,
+                                             customDefs);
+               alPolicies.add(policyObj);
                }
         return alPolicies;
        }
     }
 
     @SuppressWarnings("unchecked")
-    private ArrayList<Object> _tplPolicies() {
+    private LinkedHashMap<String,Object> _tplPolicies() {
         if(tpl.get(POLICIES) != null) {
-               return (ArrayList<Object>)tpl.get(POLICIES);
+               return (LinkedHashMap<String,Object>)tpl.get(POLICIES);
         }
         else {
-               return new ArrayList<Object>();
+               return new LinkedHashMap<>();
         }
     }
 
 
 import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
 import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
+import java.util.Map;
 
 public class GroupType extends StatefulEntityType {
 
        public String getType() {
                return groupType;
        }
-
+       
+    @SuppressWarnings("unchecked")
+       public ArrayList<CapabilityTypeDef> getCapabilitiesObjects() {
+        // Return a list of capability objects
+               ArrayList<CapabilityTypeDef> typecapabilities = new ArrayList<>();
+               LinkedHashMap<String,Object> caps = (LinkedHashMap<String,Object>)getValue(CAPABILITIES, null, true);
+        if(caps != null) {
+            // 'cname' is symbolic name of the capability
+            // 'cvalue' is a dict { 'type': <capability type name> }
+               for(Map.Entry<String,Object> me: caps.entrySet()) {
+                       String cname = me.getKey();
+                       LinkedHashMap<String,String> cvalue = (LinkedHashMap<String,String>)me.getValue();
+                       String ctype = cvalue.get("type");
+                       CapabilityTypeDef cap = new CapabilityTypeDef(cname,ctype,type,customDef);
+                       typecapabilities.add(cap);
+               }
+        }
+        return typecapabilities;
+       }
+ 
+       public LinkedHashMap<String,CapabilityTypeDef> getCapabilities() {
+        // Return a dictionary of capability name-objects pairs
+               LinkedHashMap<String,CapabilityTypeDef> caps = new LinkedHashMap<>();
+               for(CapabilityTypeDef ctd: getCapabilitiesObjects()) {
+                       caps.put(ctd.getName(),ctd);
+               }
+               return caps;
+       }
 
 }