diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/AbstractAxiomItem.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/AbstractAxiomItem.java
index c350798deb4..1110b3b07fe 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/AbstractAxiomItem.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/AbstractAxiomItem.java
@@ -19,7 +19,7 @@ public Optional<AxiomItemDefinition> definition() {
     }
 
     @Override
-    public AxiomIdentifier name() {
+    public AxiomName name() {
         return definition.name();
     }
 }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomItem.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomItem.java
index def79148443..9f42bab3648 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomItem.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomItem.java
@@ -9,7 +9,7 @@
 
 public interface AxiomItem<V> {
 
-    AxiomIdentifier name();
+    AxiomName name();
     Optional<AxiomItemDefinition> definition();
 
     Collection<AxiomValue<V>> values();
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomIdentifier.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomName.java
similarity index 68%
rename from infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomIdentifier.java
rename to infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomName.java
index a3c03867c70..46d14346409 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomIdentifier.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomName.java
@@ -11,13 +11,13 @@
 import com.google.common.base.Preconditions;
 import com.google.common.base.Strings;
 
-public class AxiomIdentifier {
+public class AxiomName {
 
     public static final String AXIOM_NAMESPACE = "https://ns.evolveum.com/axiom/language";
     private final String namespace;
     private final String localName;
 
-    public AxiomIdentifier(String namespace, String localName) {
+    public AxiomName(String namespace, String localName) {
         this.namespace = Preconditions.checkNotNull(namespace, "namespace");
         this.localName = Preconditions.checkNotNull(localName, "localName");
     }
@@ -43,9 +43,9 @@ public int hashCode() {
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
-        if (!(obj instanceof AxiomIdentifier))
+        if (!(obj instanceof AxiomName))
             return false;
-        AxiomIdentifier other = (AxiomIdentifier) obj;
+        AxiomName other = (AxiomName) obj;
         if (localName == null) {
             if (other.localName != null)
                 return false;
@@ -67,31 +67,31 @@ public String toString() {
         return "(" + namespace + ")" +localName;
     }
 
-    public static AxiomIdentifier axiom(String identifier) {
-        return new AxiomIdentifier(AXIOM_NAMESPACE, identifier);
+    public static AxiomName axiom(String identifier) {
+        return new AxiomName(AXIOM_NAMESPACE, identifier);
     }
 
-    public static AxiomIdentifier from(String namespace, String localName) {
-        return new AxiomIdentifier(namespace, localName);
+    public static AxiomName from(String namespace, String localName) {
+        return new AxiomName(namespace, localName);
     }
 
-    public boolean sameNamespace(AxiomIdentifier other) {
+    public boolean sameNamespace(AxiomName other) {
         return this.namespace().equals(other.namespace());
     }
 
-    public AxiomIdentifier localName(String name) {
-        return AxiomIdentifier.from(namespace, name);
+    public AxiomName localName(String name) {
+        return AxiomName.from(namespace, name);
     }
 
-    public AxiomIdentifier namespace(String targetNamespace) {
-        return AxiomIdentifier.from(targetNamespace, localName);
+    public AxiomName namespace(String targetNamespace) {
+        return AxiomName.from(targetNamespace, localName);
     }
 
-    public AxiomIdentifier defaultNamespace() {
-        return AxiomIdentifier.from("", localName);
+    public AxiomName defaultNamespace() {
+        return AxiomName.from("", localName);
     }
 
-    public static AxiomIdentifier local(@NotNull String localName) {
+    public static AxiomName local(@NotNull String localName) {
         return from("", localName);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValue.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValue.java
index 881a4622978..77f7df5b312 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValue.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValue.java
@@ -23,7 +23,7 @@ default Optional<AxiomItem<?>> item(AxiomItemDefinition def) {
     }
 
     @SuppressWarnings("unchecked")
-    default <T> Optional<AxiomItem<T>> item(AxiomIdentifier name) {
+    default <T> Optional<AxiomItem<T>> item(AxiomName name) {
         return items().stream().filter(value -> name.equals(value.name())).findFirst().map(v -> (AxiomItem<T>) v);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueBuilder.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueBuilder.java
index 65114745be9..052d846c035 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueBuilder.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueBuilder.java
@@ -18,7 +18,7 @@ public class AxiomValueBuilder<V,T extends AxiomValue<V>> implements Lazy.Suppli
     private final AxiomTypeDefinition type;
 
     private AxiomValueFactory<V,T> factory;
-    private Map<AxiomIdentifier, Supplier<? extends AxiomItem<?>>> children = new LinkedHashMap<>();
+    private Map<AxiomName, Supplier<? extends AxiomItem<?>>> children = new LinkedHashMap<>();
     private V value;
 
     public AxiomValueBuilder(AxiomTypeDefinition type, AxiomValueFactory<V,T> factory) {
@@ -38,22 +38,22 @@ public void setValue(V value) {
         this.value = value;
     }
 
-    public void add(AxiomIdentifier name, Supplier<? extends AxiomItem<?>> child) {
+    public void add(AxiomName name, Supplier<? extends AxiomItem<?>> child) {
         children.put(name, child);
     }
 
-    public Supplier<? extends AxiomItem<?>> get(AxiomIdentifier name) {
+    public Supplier<? extends AxiomItem<?>> get(AxiomName name) {
         return children.get(name);
     }
 
-    public Supplier<? extends AxiomItem<?>> get(AxiomIdentifier name, Function<AxiomIdentifier, ? extends Supplier<? extends AxiomItem<?>>> child) {
+    public Supplier<? extends AxiomItem<?>> get(AxiomName name, Function<AxiomName, ? extends Supplier<? extends AxiomItem<?>>> child) {
         return children.computeIfAbsent(name, child);
     }
 
     @Override
     public T get() {
-        Builder<AxiomIdentifier, AxiomItem<?>> builder = ImmutableMap.builder();
-        for(Entry<AxiomIdentifier, Supplier<? extends AxiomItem<?>>> entry : children.entrySet()) {
+        Builder<AxiomName, AxiomItem<?>> builder = ImmutableMap.builder();
+        for(Entry<AxiomName, Supplier<? extends AxiomItem<?>>> entry : children.entrySet()) {
             AxiomItem<?> item = entry.getValue().get();
             builder.put(entry.getKey(), entry.getValue().get());
         }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueFactory.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueFactory.java
index 8b51c3bc12f..201845715f8 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueFactory.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/AxiomValueFactory.java
@@ -6,6 +6,6 @@
 
 public interface AxiomValueFactory<V,T extends AxiomValue<V>> {
 
-    T create(AxiomTypeDefinition def, V value, Map<AxiomIdentifier, AxiomItem<?>> items);
+    T create(AxiomTypeDefinition def, V value, Map<AxiomName, AxiomItem<?>> items);
 }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/meta/Inheritance.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/meta/Inheritance.java
index 7fe174266cc..8d203a02896 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/meta/Inheritance.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/meta/Inheritance.java
@@ -1,6 +1,6 @@
 package com.evolveum.axiom.api.meta;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
 
 public interface Inheritance {
@@ -11,25 +11,25 @@ public interface Inheritance {
     Inheritance CURRENT = NO_CHANGE;
 
 
-    static AxiomIdentifier adapt(AxiomIdentifier parent, AxiomIdentifier child) {
+    static AxiomName adapt(AxiomName parent, AxiomName child) {
         return CURRENT.apply(parent, child);
     }
 
-    static AxiomIdentifier adapt(AxiomIdentifier parent, AxiomItemDefinition child) {
+    static AxiomName adapt(AxiomName parent, AxiomItemDefinition child) {
         return child.inherited() ? adapt(parent, child.name()) : child.name();
     }
 
-    AxiomIdentifier apply(AxiomIdentifier parent, AxiomIdentifier child);
+    AxiomName apply(AxiomName parent, AxiomName child);
 
-    static AxiomIdentifier inheritNamespace(AxiomIdentifier parent, AxiomIdentifier name) {
+    static AxiomName inheritNamespace(AxiomName parent, AxiomName name) {
         return parent.localName(name.localName());
     }
 
-    static AxiomIdentifier noNamespace(AxiomIdentifier parent, AxiomIdentifier name) {
+    static AxiomName noNamespace(AxiomName parent, AxiomName name) {
         return name.defaultNamespace();
     }
 
-    static AxiomIdentifier noChange(AxiomIdentifier parent, AxiomIdentifier name) {
+    static AxiomName noChange(AxiomName parent, AxiomName name) {
         return name;
     }
 }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinition.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinition.java
index 7837b4e140e..1fad4a318cd 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinition.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinition.java
@@ -3,7 +3,7 @@
 import java.util.Collection;
 import java.util.Set;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomValue;
 import com.google.common.collect.ImmutableSet;
 
@@ -18,7 +18,7 @@ default AxiomIdentifierDefinition get() {
 
     Scope scope();
 
-    AxiomIdentifier space();
+    AxiomName space();
 
     enum Scope {
         GLOBAL,
@@ -26,11 +26,11 @@ enum Scope {
         LOCAL
     }
 
-    static AxiomIdentifierDefinition global(AxiomIdentifier name, AxiomItemDefinition... components) {
+    static AxiomIdentifierDefinition global(AxiomName name, AxiomItemDefinition... components) {
         return new AxiomIdentifierDefinitionImpl(ImmutableSet.copyOf(components), name, Scope.GLOBAL);
     }
 
-    static AxiomIdentifierDefinition local(AxiomIdentifier name, AxiomItemDefinition... components) {
+    static AxiomIdentifierDefinition local(AxiomName name, AxiomItemDefinition... components) {
         return new AxiomIdentifierDefinitionImpl(ImmutableSet.copyOf(components), name, Scope.LOCAL);
     }
 
@@ -47,11 +47,11 @@ static Scope scope(String scope) {
         throw new IllegalArgumentException("Unknown scope " + scope);
     }
 
-    static AxiomIdentifierDefinition from(AxiomIdentifier space, Scope scope, Set<AxiomItemDefinition> members) {
+    static AxiomIdentifierDefinition from(AxiomName space, Scope scope, Set<AxiomItemDefinition> members) {
         return new AxiomIdentifierDefinitionImpl(ImmutableSet.copyOf(members), space, scope);
     }
 
-    static AxiomIdentifierDefinition parent(AxiomIdentifier name, AxiomItemDefinition... components) {
+    static AxiomIdentifierDefinition parent(AxiomName name, AxiomItemDefinition... components) {
         return new AxiomIdentifierDefinitionImpl(ImmutableSet.copyOf(components), name, Scope.PARENT);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinitionImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinitionImpl.java
index 366b2b66f02..53e485bbf1f 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinitionImpl.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomIdentifierDefinitionImpl.java
@@ -3,18 +3,18 @@
 import java.util.Optional;
 import java.util.Set;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.google.common.collect.ImmutableSet;
 
 class AxiomIdentifierDefinitionImpl implements AxiomIdentifierDefinition {
 
     private Set<AxiomItemDefinition> components;
 
-    private AxiomIdentifier space;
+    private AxiomName space;
 
     private Scope scope;
 
-    public AxiomIdentifierDefinitionImpl(Set<AxiomItemDefinition> components, AxiomIdentifier space, Scope scope) {
+    public AxiomIdentifierDefinitionImpl(Set<AxiomItemDefinition> components, AxiomName space, Scope scope) {
         super();
         this.components = ImmutableSet.copyOf(components);
         this.space = space;
@@ -32,7 +32,7 @@ public Scope scope() {
     }
 
     @Override
-    public AxiomIdentifier space() {
+    public AxiomName space() {
         return space;
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomItemDefinition.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomItemDefinition.java
index 86ef91612b5..a925a4b0807 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomItemDefinition.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomItemDefinition.java
@@ -6,7 +6,7 @@
  */
 package com.evolveum.axiom.api.schema;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.lang.api.IdentifierSpaceKey;
 import com.google.common.base.MoreObjects;
@@ -14,9 +14,9 @@
 
 public interface AxiomItemDefinition extends AxiomNamedDefinition, AxiomValue<AxiomItemDefinition> {
 
-    AxiomIdentifier ROOT_SPACE = AxiomIdentifier.axiom("AxiomRootDefinition");
-    AxiomIdentifier SPACE = AxiomIdentifier.axiom("AxiomItemDefinition");
-    AxiomIdentifier NAME = AxiomIdentifier.axiom("name");
+    AxiomName ROOT_SPACE = AxiomName.axiom("AxiomRootDefinition");
+    AxiomName SPACE = AxiomName.axiom("AxiomItemDefinition");
+    AxiomName NAME = AxiomName.axiom("name");
 
     @Override
     default AxiomItemDefinition get() {
@@ -47,7 +47,7 @@ static String toString(AxiomItemDefinition def) {
                 .toString();
     }
 
-    static AxiomItemDefinition derived(AxiomIdentifier name , AxiomItemDefinition source) {
+    static AxiomItemDefinition derived(AxiomName name , AxiomItemDefinition source) {
         return new DelegatedItemDefinition() {
 
             @Override
@@ -56,13 +56,13 @@ protected AxiomItemDefinition delegate() {
             }
 
             @Override
-            public AxiomIdentifier name() {
+            public AxiomName name() {
                 return name;
             }
         };
     }
 
-    static IdentifierSpaceKey identifier(AxiomIdentifier name) {
+    static IdentifierSpaceKey identifier(AxiomName name) {
         return IdentifierSpaceKey.from(ImmutableMap.of(NAME, name));
     }
 
@@ -78,7 +78,7 @@ interface Extended extends AxiomItemDefinition {
 
     }
 
-    default AxiomItemDefinition derived(AxiomIdentifier name) {
+    default AxiomItemDefinition derived(AxiomName name) {
         return derived(name, this);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomNamedDefinition.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomNamedDefinition.java
index c726a8cb70d..23e07296f81 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomNamedDefinition.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomNamedDefinition.java
@@ -6,10 +6,10 @@
  */
 package com.evolveum.axiom.api.schema;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 
 public interface AxiomNamedDefinition {
 
-    AxiomIdentifier name();
+    AxiomName name();
     String documentation();
 }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomSchemaContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomSchemaContext.java
index 8dcd350c001..6a0605bfd8f 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomSchemaContext.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomSchemaContext.java
@@ -3,15 +3,15 @@
 import java.util.Collection;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 
 public interface AxiomSchemaContext {
 
     Collection<AxiomItemDefinition> roots();
 
-    Optional<AxiomItemDefinition> getRoot(AxiomIdentifier type);
+    Optional<AxiomItemDefinition> getRoot(AxiomName type);
 
-    Optional<AxiomTypeDefinition> getType(AxiomIdentifier type);
+    Optional<AxiomTypeDefinition> getType(AxiomName type);
 
     Collection<AxiomTypeDefinition> types();
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomTypeDefinition.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomTypeDefinition.java
index 0298895be02..023dc562e07 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomTypeDefinition.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/AxiomTypeDefinition.java
@@ -11,7 +11,7 @@
 import java.util.Optional;
 import java.util.stream.Collectors;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.meta.Inheritance;
 import com.evolveum.axiom.lang.api.IdentifierSpaceKey;
@@ -19,8 +19,8 @@
 
 public interface AxiomTypeDefinition extends AxiomNamedDefinition, AxiomValue<AxiomTypeDefinition> {
 
-    public final AxiomIdentifier IDENTIFIER_MEMBER = AxiomIdentifier.axiom("name");
-    public final AxiomIdentifier SPACE = AxiomIdentifier.axiom("AxiomTypeDefinition");
+    public final AxiomName IDENTIFIER_MEMBER = AxiomName.axiom("name");
+    public final AxiomName SPACE = AxiomName.axiom("AxiomTypeDefinition");
 
 
     @Override
@@ -37,11 +37,11 @@ default Optional<AxiomTypeDefinition> type() {
 
     Optional<AxiomTypeDefinition> superType();
 
-    Map<AxiomIdentifier, AxiomItemDefinition> itemDefinitions();
+    Map<AxiomName, AxiomItemDefinition> itemDefinitions();
 
     Collection<AxiomIdentifierDefinition> identifierDefinitions();
 
-    default Optional<AxiomItemDefinition> itemDefinition(AxiomIdentifier child) {
+    default Optional<AxiomItemDefinition> itemDefinition(AxiomName child) {
         AxiomItemDefinition maybe = itemDefinitions().get(child);
         if(maybe == null) {
             maybe = itemDefinitions().get(Inheritance.adapt(name(), child));
@@ -52,7 +52,7 @@ default Optional<AxiomItemDefinition> itemDefinition(AxiomIdentifier child) {
         return Optional.ofNullable(maybe).or(() -> superType().flatMap(s -> s.itemDefinition(child)));
     }
 
-    static IdentifierSpaceKey identifier(AxiomIdentifier name) {
+    static IdentifierSpaceKey identifier(AxiomName name) {
         return IdentifierSpaceKey.from(ImmutableMap.of(IDENTIFIER_MEMBER, name));
     }
 
@@ -60,7 +60,7 @@ default Collection<AxiomItemDefinition> requiredItems() {
         return itemDefinitions().values().stream().filter(AxiomItemDefinition::required).collect(Collectors.toList());
     }
 
-    default Optional<AxiomItemDefinition> itemDefinition(AxiomIdentifier parentItem, AxiomIdentifier name) {
+    default Optional<AxiomItemDefinition> itemDefinition(AxiomName parentItem, AxiomName name) {
         return itemDefinition(Inheritance.adapt(parentItem, name));
     }
 
@@ -72,7 +72,7 @@ default boolean isSupertypeOf(AxiomTypeDefinition other) {
         return other.isSubtypeOf(this);
     }
 
-    default boolean isSubtypeOf(AxiomIdentifier other) {
+    default boolean isSubtypeOf(AxiomName other) {
         Optional<AxiomTypeDefinition> current = Optional.of(this);
         while(current.isPresent()) {
             if(current.get().name().equals(other)) {
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/DelegatedItemDefinition.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/DelegatedItemDefinition.java
index e58e07ba380..7d12075c28f 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/DelegatedItemDefinition.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/schema/DelegatedItemDefinition.java
@@ -3,7 +3,7 @@
 import java.util.Collection;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 
 abstract class DelegatedItemDefinition implements AxiomItemDefinition {
@@ -26,7 +26,7 @@ public Collection<AxiomItem<?>> items() {
     }
 
     @Override
-    public AxiomIdentifier name() {
+    public AxiomName name() {
         return delegate().name();
     }
 
@@ -41,7 +41,7 @@ public Optional<AxiomItem<?>> item(AxiomItemDefinition def) {
     }
 
     @Override
-    public <T> Optional<AxiomItem<T>> item(AxiomIdentifier name) {
+    public <T> Optional<AxiomItem<T>> item(AxiomName name) {
         return delegate().item(name);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomBuilderStreamTarget.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomBuilderStreamTarget.java
index a27c5c8d021..6d723b9e8e7 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomBuilderStreamTarget.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomBuilderStreamTarget.java
@@ -9,7 +9,7 @@
 import java.util.Deque;
 import java.util.LinkedList;
 import java.util.Optional;
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
 import com.evolveum.axiom.concepts.SourceLocation;
 import com.evolveum.axiom.lang.spi.AxiomIdentifierResolver;
@@ -61,7 +61,7 @@ public void endValue(SourceLocation loc) {
     }
 
     @Override
-    public void startItem(AxiomIdentifier item, SourceLocation loc) {
+    public void startItem(AxiomName item, SourceLocation loc) {
         Optional<AxiomItemDefinition> childDef = value(current()).childDef(item);
         AxiomSyntaxException.check(childDef.isPresent(), loc , "Item %s not allowed in %s", item, current().name());
         offer(value(current()).startItem(item, loc));
@@ -73,7 +73,7 @@ public void endItem(SourceLocation loc) {
     }
 
     private interface Builder {
-        AxiomIdentifier name();
+        AxiomName name();
 
         AxiomIdentifierResolver itemResolver();
 
@@ -87,8 +87,8 @@ public interface ItemBuilder extends Builder {
     }
 
     public interface ValueBuilder extends Builder {
-        Optional<AxiomItemDefinition> childDef(AxiomIdentifier statement);
-        ItemBuilder startItem(AxiomIdentifier identifier, SourceLocation loc);
+        Optional<AxiomItemDefinition> childDef(AxiomName statement);
+        ItemBuilder startItem(AxiomName identifier, SourceLocation loc);
         void endValue(SourceLocation loc);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemStream.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemStream.java
index a20c7bfc64e..aaa06e4ad6d 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemStream.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemStream.java
@@ -1,13 +1,13 @@
 package com.evolveum.axiom.api.stream;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.concepts.SourceLocation;
 import com.evolveum.axiom.lang.spi.AxiomIdentifierResolver;
 
 public interface AxiomItemStream {
 
     interface Target {
-        void startItem(AxiomIdentifier item, SourceLocation loc);
+        void startItem(AxiomName item, SourceLocation loc);
         void startValue(Object value, SourceLocation loc);
         void endValue(SourceLocation loc);
         void endItem(SourceLocation loc);
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemTarget.java b/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemTarget.java
index 9484091ad8c..6084f7afe18 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemTarget.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/api/stream/AxiomItemTarget.java
@@ -3,7 +3,7 @@
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomItemBuilder;
 import com.evolveum.axiom.api.AxiomValue;
@@ -34,8 +34,8 @@ public AxiomItem<?> get() {
     private final class Root implements ValueBuilder {
 
         @Override
-        public AxiomIdentifier name() {
-            return AxiomIdentifier.axiom("AbstractRoot");
+        public AxiomName name() {
+            return AxiomName.axiom("AbstractRoot");
         }
 
         @Override
@@ -49,12 +49,12 @@ public AxiomIdentifierResolver valueResolver() {
         }
 
         @Override
-        public Optional<AxiomItemDefinition> childDef(AxiomIdentifier statement) {
+        public Optional<AxiomItemDefinition> childDef(AxiomName statement) {
             return context.getRoot(statement);
         }
 
         @Override
-        public ItemBuilder startItem(AxiomIdentifier identifier, SourceLocation loc) {
+        public ItemBuilder startItem(AxiomName identifier, SourceLocation loc) {
             result = new Item<>(childDef(identifier).get());
             return result;
         }
@@ -75,7 +75,7 @@ public Item(AxiomItemDefinition definition) {
         }
 
         @Override
-        public AxiomIdentifier name() {
+        public AxiomName name() {
             return builder.definition().name();
         }
 
@@ -125,7 +125,7 @@ public Value(V value, AxiomTypeDefinition type) {
         }
 
         @Override
-        public AxiomIdentifier name() {
+        public AxiomName name() {
             return builder.type().name();
         }
 
@@ -140,12 +140,12 @@ public AxiomIdentifierResolver valueResolver() {
         }
 
         @Override
-        public Optional<AxiomItemDefinition> childDef(AxiomIdentifier statement) {
+        public Optional<AxiomItemDefinition> childDef(AxiomName statement) {
             return builder.type().itemDefinition(statement);
         }
 
         @Override
-        public ItemBuilder startItem(AxiomIdentifier identifier, SourceLocation loc) {
+        public ItemBuilder startItem(AxiomName identifier, SourceLocation loc) {
             Object itemImpl = builder.get(identifier, (id) -> {
                 return new Item(childDef(identifier).get());
             });
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AbstractAxiomAntlrVisitor.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AbstractAxiomAntlrVisitor.java
index 443bb53d666..093a7037eff 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AbstractAxiomAntlrVisitor.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AbstractAxiomAntlrVisitor.java
@@ -11,7 +11,7 @@
 
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.Token;
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.stream.AxiomItemStream;
 import com.evolveum.axiom.concepts.SourceLocation;
 import com.evolveum.axiom.lang.antlr.AxiomParser.ArgumentContext;
@@ -21,15 +21,15 @@
 
 public abstract class AbstractAxiomAntlrVisitor<T> extends AxiomBaseVisitor<T> {
 
-    private final Optional<Set<AxiomIdentifier>> limit;
+    private final Optional<Set<AxiomName>> limit;
     private final String sourceName;
 
-    public AbstractAxiomAntlrVisitor(String name, Set<AxiomIdentifier> limit) {
+    public AbstractAxiomAntlrVisitor(String name, Set<AxiomName> limit) {
         this.sourceName = name;
         this.limit = Optional.ofNullable(limit);
     }
 
-    private AxiomIdentifier statementIdentifier(IdentifierContext identifier) {
+    private AxiomName statementIdentifier(IdentifierContext identifier) {
         String prefix = nullableText(identifier.prefix());
         String localName = identifier.localIdentifier().getText();
         return resolveItemName(prefix, localName);
@@ -37,8 +37,8 @@ private AxiomIdentifier statementIdentifier(IdentifierContext identifier) {
 
 
     protected abstract AxiomItemStream.Target delegate();
-    protected abstract AxiomIdentifier resolveItemName(String prefix, String localName);
-    protected abstract AxiomIdentifier resolveArgument(String prefix, String localName);
+    protected abstract AxiomName resolveItemName(String prefix, String localName);
+    protected abstract AxiomName resolveArgument(String prefix, String localName);
 
     private String nullableText(ParserRuleContext prefix) {
         return prefix != null ? prefix.getText() : "";
@@ -46,7 +46,7 @@ private String nullableText(ParserRuleContext prefix) {
 
     @Override
     public final T visitStatement(StatementContext ctx) {
-        AxiomIdentifier identifier = statementIdentifier(ctx.identifier());
+        AxiomName identifier = statementIdentifier(ctx.identifier());
         if(canEmit(identifier)) {
             SourceLocation start = sourceLocation(ctx.identifier().start);
             delegate().startItem(identifier, start);
@@ -78,7 +78,7 @@ private Object convert(ArgumentContext ctx) {
         }
     }
 
-    private boolean canEmit(AxiomIdentifier identifier) {
+    private boolean canEmit(AxiomName identifier) {
         if (limit.isPresent()) {
             return limit.get().contains(identifier);
         }
@@ -91,11 +91,11 @@ public final T visitArgument(ArgumentContext ctx) {
         return defaultResult();
     }
 
-    private AxiomIdentifier convert(IdentifierContext argument) {
+    private AxiomName convert(IdentifierContext argument) {
         return argumentIdentifier(argument);
     }
 
-    private AxiomIdentifier argumentIdentifier(IdentifierContext identifier) {
+    private AxiomName argumentIdentifier(IdentifierContext identifier) {
         String prefix = nullableText(identifier.prefix());
         String localName = identifier.localIdentifier().getText();
         return resolveArgument(prefix, localName);
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrStatementSource.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrStatementSource.java
index d1134c3fad3..d8ada5079f3 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrStatementSource.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrStatementSource.java
@@ -15,7 +15,7 @@
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.stream.AxiomItemStream;
 import com.evolveum.axiom.lang.antlr.AxiomParser.StatementContext;
 import com.evolveum.axiom.lang.spi.AxiomIdentifierResolver;
@@ -64,13 +64,13 @@ public final void stream(AxiomItemStream.TargetWithResolver target) {
         stream(target, Optional.empty());
     }
 
-    public final void stream(AxiomItemStream.TargetWithResolver target, Optional<Set<AxiomIdentifier>> emitOnly) {
+    public final void stream(AxiomItemStream.TargetWithResolver target, Optional<Set<AxiomName>> emitOnly) {
         AxiomAntlrVisitor2<?> visitor = new AxiomAntlrVisitor2<>(sourceName, target, emitOnly.orElse(null));
         visitor.visit(root);
     }
 
     public final void stream(AxiomIdentifierResolver statements, AxiomIdentifierResolver arguments, AxiomItemStream.Target listener,
-            Optional<Set<AxiomIdentifier>> emitOnly) {
+            Optional<Set<AxiomName>> emitOnly) {
         AxiomAntlrVisitor<?> visitor = new AxiomAntlrVisitor<>(sourceName, statements, arguments, listener, emitOnly.orElse(null));
         visitor.visit(root);
     }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor.java
index b5c3deb0bfd..b667656d16b 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor.java
@@ -8,7 +8,7 @@
 
 import java.util.Set;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.stream.AxiomItemStream;
 import com.evolveum.axiom.api.stream.AxiomItemStream.Target;
 import com.evolveum.axiom.lang.spi.AxiomIdentifierResolver;
@@ -20,7 +20,7 @@ public class AxiomAntlrVisitor<T> extends AbstractAxiomAntlrVisitor<T> {
     private final AxiomItemStream.Target delegate;
 
     public AxiomAntlrVisitor(String name, AxiomIdentifierResolver statements, AxiomIdentifierResolver arguments, AxiomItemStream.Target delegate,
-            Set<AxiomIdentifier> limit) {
+            Set<AxiomName> limit) {
         super(name, limit);
         this.statements = statements;
         this.arguments = arguments;
@@ -28,12 +28,12 @@ public AxiomAntlrVisitor(String name, AxiomIdentifierResolver statements, AxiomI
     }
 
     @Override
-    protected AxiomIdentifier resolveArgument(String prefix, String localName) {
+    protected AxiomName resolveArgument(String prefix, String localName) {
         return arguments.resolveIdentifier(prefix, localName);
     }
 
     @Override
-    protected AxiomIdentifier resolveItemName(String prefix, String localName) {
+    protected AxiomName resolveItemName(String prefix, String localName) {
         return statements.resolveIdentifier(prefix, localName);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor2.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor2.java
index bf9e8f8668e..b0304229c5c 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor2.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomAntlrVisitor2.java
@@ -8,7 +8,7 @@
 
 import java.util.Set;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.stream.AxiomItemStream;
 import com.evolveum.axiom.api.stream.AxiomItemStream.Target;
 
@@ -17,18 +17,18 @@ public class AxiomAntlrVisitor2<T> extends AbstractAxiomAntlrVisitor<T> {
     private final AxiomItemStream.TargetWithResolver delegate;
 
     public AxiomAntlrVisitor2(String name, AxiomItemStream.TargetWithResolver delegate,
-            Set<AxiomIdentifier> limit) {
+            Set<AxiomName> limit) {
         super(name, limit);
         this.delegate = delegate;
     }
 
     @Override
-    protected AxiomIdentifier resolveArgument(String prefix, String localName) {
+    protected AxiomName resolveArgument(String prefix, String localName) {
         return delegate.valueResolver().resolveIdentifier(prefix, localName);
     }
 
     @Override
-    protected AxiomIdentifier resolveItemName(String prefix, String localName) {
+    protected AxiomName resolveItemName(String prefix, String localName) {
         return delegate.itemResolver().resolveIdentifier(prefix, localName);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomModelStatementSource.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomModelStatementSource.java
index 969afc62e53..f34a115b3d0 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomModelStatementSource.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/antlr/AxiomModelStatementSource.java
@@ -18,7 +18,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.stream.AxiomItemStream;
 import com.evolveum.axiom.lang.antlr.AxiomParser.StatementContext;
 import com.evolveum.axiom.lang.spi.AxiomIdentifierResolver;
@@ -65,7 +65,7 @@ public String namespace() {
 
 
     public void stream(AxiomIdentifierResolver resolver, AxiomItemStream.Target listener,
-            Optional<Set<AxiomIdentifier>> emitOnly) {
+            Optional<Set<AxiomName>> emitOnly) {
         stream(resolver.or(this), BUILTIN_TYPES.or(this).or(resolver), listener, emitOnly);
     }
 
@@ -91,13 +91,13 @@ private static String namespace(StatementContext c) {
     }
 
     @Override
-    public AxiomIdentifier resolveIdentifier(@Nullable String prefix, @NotNull String localName) {
+    public AxiomName resolveIdentifier(@Nullable String prefix, @NotNull String localName) {
         if(prefix == null) {
             prefix = "";
         }
         String maybeNs = imports.get(prefix);
         if(maybeNs != null) {
-            return AxiomIdentifier.from(maybeNs, localName);
+            return AxiomName.from(maybeNs, localName);
         }
         return null;
     }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomBuiltIn.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomBuiltIn.java
index 854f7ca8fc9..d3f57bbed81 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomBuiltIn.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomBuiltIn.java
@@ -11,7 +11,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomIdentifierDefinition;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
 import com.evolveum.axiom.api.schema.AxiomTypeDefinition;
@@ -22,7 +22,7 @@
 
 public class AxiomBuiltIn {
 
-    public static final Lazy<Map<AxiomIdentifier, AxiomItemDefinition>> EMPTY = Lazy.instant(ImmutableMap.of());
+    public static final Lazy<Map<AxiomName, AxiomItemDefinition>> EMPTY = Lazy.instant(ImmutableMap.of());
     public static final Lazy<AxiomItemDefinition> NO_ARGUMENT = Lazy.nullValue();
 
 
@@ -58,13 +58,13 @@ public static class Item implements AxiomItemDefinition {
         public static final AxiomItemDefinition USES = new Item("uses", Type.TYPE_REFERENCE, true);
 
 
-        private final AxiomIdentifier identifier;
+        private final AxiomName identifier;
         private final AxiomTypeDefinition type;
         private boolean required;
 
 
         private Item(String identifier, AxiomTypeDefinition type, boolean required) {
-            this.identifier = AxiomIdentifier.axiom(identifier);
+            this.identifier = AxiomName.axiom(identifier);
             this.type = type;
             this.required = required;
         }
@@ -75,7 +75,7 @@ public Optional<AxiomTypeDefinition> type() {
         }
 
         @Override
-        public AxiomIdentifier name() {
+        public AxiomName name() {
             return identifier;
         }
 
@@ -130,7 +130,7 @@ public AxiomTypeDefinition definingType() {
     public static class Type implements AxiomTypeDefinition {
         public static final Type UUID = new Type("uuid");
         public static final Type STRING = new Type("string");
-        public static final Type IDENTIFIER = new Type("AxiomIdentifier");
+        public static final Type IDENTIFIER = new Type("AxiomName");
         public static final Type TYPE_REFERENCE = new Type("AxiomTypeReference", null, () -> Item.NAME, () -> itemDefs(
                     Item.NAME,
                     Item.REF_TARGET
@@ -206,40 +206,40 @@ public Collection<AxiomIdentifierDefinition> identifierDefinitions() {
         public static final Type IMPORT_DEFINITION = new Type("AxiomImportDeclaration");
         public static final Type EXTENSION_DEFINITION = new Type("AxiomExtensionDefinition");
 
-        private final AxiomIdentifier identifier;
+        private final AxiomName identifier;
         private final AxiomTypeDefinition superType;
         private final Lazy<AxiomItemDefinition> argument;
-        private final Lazy<Map<AxiomIdentifier, AxiomItemDefinition>> items;
+        private final Lazy<Map<AxiomName, AxiomItemDefinition>> items;
 
 
         private Type(String identifier) {
             this(identifier, null, Lazy.nullValue(), EMPTY);
         }
 
-        private Type(String identifier, Lazy.Supplier<Map<AxiomIdentifier, AxiomItemDefinition>> items) {
+        private Type(String identifier, Lazy.Supplier<Map<AxiomName, AxiomItemDefinition>> items) {
             this(identifier, null, Lazy.nullValue(), Lazy.from(items));
         }
 
-        private Type(String identifier, AxiomTypeDefinition superType, Lazy.Supplier<Map<AxiomIdentifier, AxiomItemDefinition>> items) {
+        private Type(String identifier, AxiomTypeDefinition superType, Lazy.Supplier<Map<AxiomName, AxiomItemDefinition>> items) {
             this(identifier, superType, NO_ARGUMENT, Lazy.from(items));
         }
 
 
         private Type(String identifier, AxiomTypeDefinition superType, Lazy.Supplier<AxiomItemDefinition> argument,
-                Lazy.Supplier<Map<AxiomIdentifier, AxiomItemDefinition>> items) {
+                Lazy.Supplier<Map<AxiomName, AxiomItemDefinition>> items) {
             this(identifier, superType, Lazy.from(argument), Lazy.from(items));
         }
 
         private Type(String identifier, AxiomTypeDefinition superType, Lazy<AxiomItemDefinition> argument,
-                Lazy<Map<AxiomIdentifier, AxiomItemDefinition>> items) {
-            this.identifier = AxiomIdentifier.axiom(identifier);
+                Lazy<Map<AxiomName, AxiomItemDefinition>> items) {
+            this.identifier = AxiomName.axiom(identifier);
             this.argument = argument;
             this.superType = superType;
             this.items = items;
         }
 
         @Override
-        public AxiomIdentifier name() {
+        public AxiomName name() {
             return identifier;
         }
 
@@ -254,12 +254,12 @@ public Optional<AxiomTypeDefinition> superType() {
         }
 
         @Override
-        public Map<AxiomIdentifier, AxiomItemDefinition> itemDefinitions() {
+        public Map<AxiomName, AxiomItemDefinition> itemDefinitions() {
             return items.get();
         }
 
-        private static Map<AxiomIdentifier, AxiomItemDefinition> itemDefs(AxiomItemDefinition... items) {
-            Builder<AxiomIdentifier, AxiomItemDefinition> builder = ImmutableMap.builder();
+        private static Map<AxiomName, AxiomItemDefinition> itemDefs(AxiomItemDefinition... items) {
+            Builder<AxiomName, AxiomItemDefinition> builder = ImmutableMap.builder();
 
             for (AxiomItemDefinition item : items) {
                 builder.put(item.name(), item);
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomModel.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomModel.java
index 441eeb9593a..c759c1c6c86 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomModel.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/AxiomModel.java
@@ -1,11 +1,11 @@
 package com.evolveum.axiom.lang.api;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 
 public interface AxiomModel {
 
-    AxiomIdentifier NAMESPACE = AxiomIdentifier.axiom("namespace");
-    AxiomIdentifier IMPORTED_NAMESPACE = AxiomIdentifier.axiom("ImportedNamespace");
+    AxiomName NAMESPACE = AxiomName.axiom("namespace");
+    AxiomName IMPORTED_NAMESPACE = AxiomName.axiom("ImportedNamespace");
     String BUILTIN_TYPES = "https://ns.evolveum.com/axiom/language";
 
     String name();
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/IdentifierSpaceKey.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/IdentifierSpaceKey.java
index 6d8826c6a52..ca8318ec2e3 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/IdentifierSpaceKey.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/api/IdentifierSpaceKey.java
@@ -3,18 +3,18 @@
 import java.util.Map;
 import java.util.Map.Entry;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.google.common.collect.ImmutableMap;
 
 public class IdentifierSpaceKey {
 
-    private final Map<AxiomIdentifier, Object> components;
+    private final Map<AxiomName, Object> components;
 
-    public IdentifierSpaceKey(Map<AxiomIdentifier, Object> components) {
+    public IdentifierSpaceKey(Map<AxiomName, Object> components) {
         this.components = ImmutableMap.copyOf(components);
     }
 
-    public Map<AxiomIdentifier, Object> components() {
+    public Map<AxiomName, Object> components() {
         return components;
     }
 
@@ -34,7 +34,7 @@ public boolean equals(Object obj) {
         return false;
     }
 
-    public static IdentifierSpaceKey from(Map<AxiomIdentifier, Object> build) {
+    public static IdentifierSpaceKey from(Map<AxiomName, Object> build) {
         return new IdentifierSpaceKey(build);
     }
 
@@ -43,7 +43,7 @@ public String toString() {
         StringBuilder b = new StringBuilder();
         b.append("[");
         boolean first = true;
-        for(Entry<AxiomIdentifier, Object> val : components().entrySet()) {
+        for(Entry<AxiomName, Object> val : components().entrySet()) {
             if(!first) {
                 b.append(",");
             }
@@ -53,7 +53,7 @@ public String toString() {
         return b.toString();
     }
 
-    public static IdentifierSpaceKey of(AxiomIdentifier key, Object value) {
+    public static IdentifierSpaceKey of(AxiomName key, Object value) {
         return from(ImmutableMap.of(key, value));
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AbstractContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AbstractContext.java
index d35d1c50888..7f8361da59f 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AbstractContext.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AbstractContext.java
@@ -3,7 +3,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
 import com.evolveum.axiom.api.schema.AxiomIdentifierDefinition.Scope;
 import com.evolveum.axiom.concepts.SourceLocation;
@@ -29,7 +29,7 @@ public AbstractContext(P context, SourceLocation loc, IdentifierSpaceHolder spac
     public P parent() {
         return parent;
     }
-    protected abstract Optional<AxiomItemDefinition> childDef(AxiomIdentifier id);
+    protected abstract Optional<AxiomItemDefinition> childDef(AxiomName id);
 
 
     protected SourceContext rootImpl() {
@@ -41,7 +41,7 @@ public SourceLocation startLocation() {
     }
 
     @Override
-    public ValueContext<?> lookup(AxiomIdentifier space, IdentifierSpaceKey key) {
+    public ValueContext<?> lookup(AxiomName space, IdentifierSpaceKey key) {
         ValueContext<?> maybe = localSpace.lookup(space, key);
         if(maybe != null) {
             return maybe;
@@ -50,7 +50,7 @@ public ValueContext<?> lookup(AxiomIdentifier space, IdentifierSpaceKey key) {
     }
 
     @Override
-    public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
+    public void register(AxiomName space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
         switch (scope) {
             case GLOBAL:
                 rootImpl().register(space, scope, key, context);
@@ -67,7 +67,7 @@ public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key,
     }
 
     @Override
-    public Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomIdentifier space) {
+    public Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomName space) {
         return localSpace.space(space);
     }
 }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomSchemaContextImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomSchemaContextImpl.java
index f9baaab7af5..d8a24de4c90 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomSchemaContextImpl.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomSchemaContextImpl.java
@@ -4,7 +4,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
 import com.evolveum.axiom.api.schema.AxiomSchemaContext;
@@ -18,9 +18,9 @@ public class AxiomSchemaContextImpl implements AxiomSchemaContext {
 
     private Map<IdentifierSpaceKey, AxiomItemDefinition> roots;
     private Map<IdentifierSpaceKey, AxiomTypeDefinition> types;
-    private Map<AxiomIdentifier, Map<IdentifierSpaceKey, AxiomValue<?>>> globals;
+    private Map<AxiomName, Map<IdentifierSpaceKey, AxiomValue<?>>> globals;
 
-    public AxiomSchemaContextImpl(Map<AxiomIdentifier,Map<IdentifierSpaceKey, AxiomValue<?>>> globalMap) {
+    public AxiomSchemaContextImpl(Map<AxiomName,Map<IdentifierSpaceKey, AxiomValue<?>>> globalMap) {
         this.globals = globalMap;
         this.roots = Maps.transformValues(globalMap.get(AxiomItemDefinition.ROOT_SPACE), AxiomItemDefinition.class::cast);
         this.types = Maps.transformValues(globalMap.get(AxiomTypeDefinition.SPACE), AxiomTypeDefinition.class::cast);
@@ -32,7 +32,7 @@ public Collection<AxiomItemDefinition> roots() {
     }
 
     @Override
-    public Optional<AxiomTypeDefinition> getType(AxiomIdentifier type) {
+    public Optional<AxiomTypeDefinition> getType(AxiomName type) {
         return Optional.ofNullable(types.get(nameKey(type)));
     }
 
@@ -42,17 +42,17 @@ public Collection<AxiomTypeDefinition> types() {
     }
 
     @Override
-    public Optional<AxiomItemDefinition> getRoot(AxiomIdentifier type) {
+    public Optional<AxiomItemDefinition> getRoot(AxiomName type) {
         return Optional.ofNullable(roots.get(nameKey(type)));
     }
 
-    private static IdentifierSpaceKey nameKey(AxiomIdentifier type) {
+    private static IdentifierSpaceKey nameKey(AxiomName type) {
         return IdentifierSpaceKey.of(AxiomTypeDefinition.IDENTIFIER_MEMBER, type);
     }
 
     public static AxiomSchemaContextImpl boostrapContext() {
         Map<IdentifierSpaceKey, AxiomValue<?>> root = ImmutableMap.of(nameKey(AxiomBuiltIn.Item.MODEL_DEFINITION.name()), AxiomBuiltIn.Item.MODEL_DEFINITION);
-        Map<AxiomIdentifier, Map<IdentifierSpaceKey, AxiomValue<?>>> global
+        Map<AxiomName, Map<IdentifierSpaceKey, AxiomValue<?>>> global
             = ImmutableMap.of(AxiomItemDefinition.ROOT_SPACE, root, AxiomTypeDefinition.SPACE, ImmutableMap.of());
         return new AxiomSchemaContextImpl(global);
     }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomStatementRule.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomStatementRule.java
index c33b538e4e6..1963a7305fc 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomStatementRule.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomStatementRule.java
@@ -1,6 +1,6 @@
 package com.evolveum.axiom.lang.impl;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
@@ -25,19 +25,19 @@ default AxiomTypeDefinition typeDefinition() {
 
         AxiomItemDefinition itemDefinition();
 
-        Dependency<NamespaceContext> namespace(AxiomIdentifier name, IdentifierSpaceKey namespaceId);
+        Dependency<NamespaceContext> namespace(AxiomName name, IdentifierSpaceKey namespaceId);
 
         <T> Dependency<AxiomItem<T>> child(AxiomItemDefinition item, Class<T> valueType);
 
         <T> Dependency<AxiomValue<T>> onlyItemValue(AxiomItemDefinition item, Class<T> valueType);
 
-        Dependency<AxiomValueContext<?>> modify(AxiomIdentifier identifierSpace, IdentifierSpaceKey identifier);
+        Dependency<AxiomValueContext<?>> modify(AxiomName identifierSpace, IdentifierSpaceKey identifier);
 
-        Dependency.Search<AxiomValue<?>> global(AxiomIdentifier identifierSpace, IdentifierSpaceKey identifier);
+        Dependency.Search<AxiomValue<?>> global(AxiomName identifierSpace, IdentifierSpaceKey identifier);
 
-        Dependency.Search<AxiomValueReference<?>> reference(AxiomIdentifier identifierSpace, IdentifierSpaceKey identifier);
+        Dependency.Search<AxiomValueReference<?>> reference(AxiomName identifierSpace, IdentifierSpaceKey identifier);
 
-        Dependency.Search<AxiomValue<?>> namespaceValue(AxiomIdentifier space, IdentifierSpaceKey itemName);
+        Dependency.Search<AxiomValue<?>> namespaceValue(AxiomName space, IdentifierSpaceKey itemName);
 
         Dependency<V> finalValue();
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomValueContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomValueContext.java
index 3cee854c673..ab6c32fe43e 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomValueContext.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/AxiomValueContext.java
@@ -1,6 +1,6 @@
 package com.evolveum.axiom.lang.impl;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
@@ -16,7 +16,7 @@ default <T> AxiomItemContext<T> childItem(AxiomItemDefinition def) {
         return childItem(def.name());
     }
 
-    <T> AxiomItemContext<T> childItem(AxiomIdentifier name);
+    <T> AxiomItemContext<T> childItem(AxiomName name);
 
     V currentValue();
 
@@ -24,7 +24,7 @@ default <T> AxiomItemContext<T> childItem(AxiomItemDefinition def) {
 
     void mergeItem(AxiomItem<?> axiomItem);
 
-    void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key);
+    void register(AxiomName space, Scope scope, IdentifierSpaceKey key);
 
     AxiomRootContext root();
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/BasicStatementRule.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/BasicStatementRule.java
index 7de2d74e3cf..cb945e20068 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/BasicStatementRule.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/BasicStatementRule.java
@@ -6,7 +6,7 @@
 import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.meta.Inheritance;
@@ -27,7 +27,7 @@
 import com.google.common.collect.ImmutableSet;
 
 
-public enum BasicStatementRule implements AxiomStatementRule<AxiomIdentifier> {
+public enum BasicStatementRule implements AxiomStatementRule<AxiomName> {
     /*
     REQUIRE_REQUIRED_ITEMS(all(),all()) {
         @Override
@@ -42,7 +42,7 @@ public void apply(Context<AxiomIdentifier> rule) throws AxiomSemanticException {
 
     MOVE_ARGUMENT_VALUE(all(),all()) {
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
             if(context.isMutable()) {
                 Optional<AxiomItemDefinition> argument = context.typeDefinition().argument();
                 if(argument.isPresent() && context.originalValue() != null) {
@@ -63,11 +63,11 @@ public boolean isApplicableTo(AxiomItemDefinition definition) {
         }
 
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
             Collection<AxiomIdentifierDefinition> idDefs = context.typeDefinition().identifierDefinitions();
-            Map<AxiomIdentifierDefinition, Map<AxiomIdentifier,Dependency<AxiomValue<Object>>>> identReq = new HashMap<>();
+            Map<AxiomIdentifierDefinition, Map<AxiomName,Dependency<AxiomValue<Object>>>> identReq = new HashMap<>();
             for(AxiomIdentifierDefinition idDef : idDefs) {
-                Map<AxiomIdentifier,Dependency<AxiomValue<Object>>> components = new HashMap<>();
+                Map<AxiomName,Dependency<AxiomValue<Object>>> components = new HashMap<>();
                 for(AxiomItemDefinition cmp : idDef.components()) {
                     components.put(cmp.name(), action.require(context.child(cmp, Object.class))
                             .unsatisfied(()-> context.error("Item '%s' is required by identifier, but not defined.", cmp.name()))
@@ -86,9 +86,9 @@ public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier
     },
     EXPAND_TYPE_REFERENCE(all(), types(Type.TYPE_REFERENCE)) {
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
 
-            Dependency<AxiomValueReference<?>> typeDef = action.require(context.child(Item.NAME, AxiomIdentifier.class)
+            Dependency<AxiomValueReference<?>> typeDef = action.require(context.child(Item.NAME, AxiomName.class)
                 .unsatisfied(() -> action.error("type name is missing."))
                 .map(v -> v.onlyValue().get())
                 .flatMap(name ->
@@ -110,8 +110,8 @@ public boolean isApplicableTo(AxiomItemDefinition definition) {
         }
 
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
-            AxiomIdentifier itemName = context.currentValue();
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
+            AxiomName itemName = context.currentValue();
             Search<AxiomValue<?>> itemDef = action.require(context.namespaceValue(AxiomItemDefinition.SPACE, AxiomItemDefinition.identifier(itemName)))
                     .notFound(() -> action.error("item '%s' was not found", itemName));
             action.apply((val) -> {
@@ -122,7 +122,7 @@ public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier
     ITEMS_FROM_SUPERTYPE(items(Item.SUPERTYPE_REFERENCE),types(Type.TYPE_REFERENCE)) {
 
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
             Dependency<AxiomTypeDefinition> typeDef =
                     action.require(
                             context.onlyItemValue(Item.REF_TARGET, AxiomTypeDefinition.class)
@@ -136,7 +136,7 @@ public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier
     ITEMS_FROM_MIXIN(items(Item.USES),types(Type.TYPE_REFERENCE)) {
 
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
             Dependency<AxiomTypeDefinition> typeDef =
                     action.require(
                             context.onlyItemValue(Item.REF_TARGET, AxiomTypeDefinition.class)
@@ -149,7 +149,7 @@ public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier
     },
     IMPORT_DEFAULT_TYPES(all(), types(Type.MODEL)) {
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
             Dependency<NamespaceContext> req = action.require(context.namespace(Item.NAMESPACE.name(), namespaceId(AxiomModel.BUILTIN_TYPES)));
             req.unsatisfied(() -> action.error("Default types not found."));
             action.apply((ctx) -> {
@@ -160,7 +160,7 @@ public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier
     EXPORT_GLOBALS_FROM_MODEL(all(), types(Type.MODEL)) {
 
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
             Dependency<String> namespace = action.require(context.child(Item.NAMESPACE, String.class).map(v -> v.onlyValue().get()));
             action.apply(ctx -> {
                 ctx.root().exportIdentifierSpace(namespaceId(namespace.get()));
@@ -170,7 +170,7 @@ public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier
     IMPORT_MODEL(all(),types(Type.IMPORT_DEFINITION)) {
 
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
             Dependency<NamespaceContext> namespace = action.require(context.child(Item.NAMESPACE, String.class)
                     .map(item -> item.onlyValue())
                     .flatMap(uri -> context.namespace(Item.NAMESPACE.name(), namespaceId(uri.get()))
@@ -185,11 +185,11 @@ public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier
     APPLY_EXTENSION(all(), types(Type.EXTENSION_DEFINITION)) {
 
         @Override
-        public void apply(Lookup<AxiomIdentifier> context, ActionBuilder<AxiomIdentifier> action) throws AxiomSemanticException {
-            Dependency<AxiomValueContext<?>> targetRef = action.require(context.child(Item.TARGET, AxiomIdentifier.class)
+        public void apply(Lookup<AxiomName> context, ActionBuilder<AxiomName> action) throws AxiomSemanticException {
+            Dependency<AxiomValueContext<?>> targetRef = action.require(context.child(Item.TARGET, AxiomName.class)
                     .map(v -> v.onlyValue().item(Item.NAME).get()))
                     .flatMap(item ->
-                        context.modify(AxiomTypeDefinition.SPACE, AxiomTypeDefinition.identifier((AxiomIdentifier) item.onlyValue().get()))
+                        context.modify(AxiomTypeDefinition.SPACE, AxiomTypeDefinition.identifier((AxiomName) item.onlyValue().get()))
                         .unsatisfied(() -> action.error("Target %s not found.",item.onlyValue().get())
                     ));
             Dependency<AxiomItem<AxiomItemDefinition>> itemDef = action.require(context.child(Item.ITEM_DEFINITION, AxiomItemDefinition.class));
@@ -213,18 +213,18 @@ public void apply(Context<AxiomIdentifier> rule) throws AxiomSemanticException {
      */
     ;
 
-    private final Set<AxiomIdentifier> items;
-    private final Set<AxiomIdentifier> types;
+    private final Set<AxiomName> items;
+    private final Set<AxiomName> types;
 
 
-    private BasicStatementRule(Set<AxiomIdentifier> items, Set<AxiomIdentifier> types) {
+    private BasicStatementRule(Set<AxiomName> items, Set<AxiomName> types) {
         this.items = ImmutableSet.copyOf(items);
         this.types = ImmutableSet.copyOf(types);
     }
 
-    static IdentifierSpaceKey keyFrom(Map<AxiomIdentifier,Dependency<AxiomValue<Object>>> ctx) {
-        ImmutableMap.Builder<AxiomIdentifier, Object> components = ImmutableMap.builder();
-        for(Entry<AxiomIdentifier, Dependency<AxiomValue<Object>>> entry : ctx.entrySet()) {
+    static IdentifierSpaceKey keyFrom(Map<AxiomName,Dependency<AxiomValue<Object>>> ctx) {
+        ImmutableMap.Builder<AxiomName, Object> components = ImmutableMap.builder();
+        for(Entry<AxiomName, Dependency<AxiomValue<Object>>> entry : ctx.entrySet()) {
             components.put(entry.getKey(), entry.getValue().get().get());
         }
         return IdentifierSpaceKey.from(components.build());
@@ -236,7 +236,7 @@ public boolean isApplicableTo(AxiomItemDefinition definition) {
             if(types.isEmpty()) {
                 return true;
             }
-            for(AxiomIdentifier type : types) {
+            for(AxiomName type : types) {
                 if(definition.typeDefinition().isSubtypeOf(type)) {
                     return true;
                 }
@@ -246,8 +246,8 @@ public boolean isApplicableTo(AxiomItemDefinition definition) {
         return false;
     }
 
-    private static ImmutableSet<AxiomIdentifier> types(AxiomTypeDefinition... types) {
-        ImmutableSet.Builder<AxiomIdentifier> builder = ImmutableSet.builder();
+    private static ImmutableSet<AxiomName> types(AxiomTypeDefinition... types) {
+        ImmutableSet.Builder<AxiomName> builder = ImmutableSet.builder();
         for (AxiomTypeDefinition item : types) {
             builder.add(item.name());
         }
@@ -255,15 +255,15 @@ private static ImmutableSet<AxiomIdentifier> types(AxiomTypeDefinition... types)
 
     }
 
-    private static ImmutableSet<AxiomIdentifier> items(AxiomItemDefinition... items) {
-        ImmutableSet.Builder<AxiomIdentifier> builder = ImmutableSet.builder();
+    private static ImmutableSet<AxiomName> items(AxiomItemDefinition... items) {
+        ImmutableSet.Builder<AxiomName> builder = ImmutableSet.builder();
         for (AxiomItemDefinition item : items) {
             builder.add(item.name());
         }
         return builder.build();
     }
 
-    private static ImmutableSet<AxiomIdentifier> all() {
+    private static ImmutableSet<AxiomName> all() {
         return ImmutableSet.of();
     }
 
@@ -271,7 +271,7 @@ private static IdentifierSpaceKey namespaceId(String uri) {
         return IdentifierSpaceKey.of(Item.NAMESPACE.name(), uri);
     }
 
-    public static void addFromType(AxiomValue<?> source, AxiomValueContext<?> target, AxiomIdentifier targetName) {
+    public static void addFromType(AxiomValue<?> source, AxiomValueContext<?> target, AxiomName targetName) {
         AxiomTypeDefinition superType = (AxiomTypeDefinition) source.get();
         Preconditions.checkState(!(superType instanceof AxiomBuiltIn.Type));
         // FIXME: Add namespace change if necessary
@@ -283,7 +283,7 @@ public static void addFromType(AxiomValue<?> source, AxiomValueContext<?> target
         Collection<AxiomItemDefinition> itemDefs = ImmutableList.copyOf(superType.itemDefinitions().values());
         for (AxiomItemDefinition item : superType.itemDefinitions().values()) {
             if(item.inherited()) {
-                final AxiomIdentifier derivedName = Inheritance.adapt(targetName, item);
+                final AxiomName derivedName = Inheritance.adapt(targetName, item);
                 item = item.derived(derivedName);
             }
             target.mergeItem(AxiomItem.from(Item.ITEM_DEFINITION, item));
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/CompositeIdentifierSpace.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/CompositeIdentifierSpace.java
index 24684043309..60472c2e11d 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/CompositeIdentifierSpace.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/CompositeIdentifierSpace.java
@@ -4,7 +4,7 @@
 import java.util.Map;
 import java.util.Set;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomIdentifierDefinition.Scope;
 import com.evolveum.axiom.lang.api.IdentifierSpaceKey;
 
@@ -24,7 +24,7 @@ public CompositeIdentifierSpace() {
     }
 
     @Override
-    public ValueContext<?> lookup(AxiomIdentifier space, IdentifierSpaceKey key) {
+    public ValueContext<?> lookup(AxiomName space, IdentifierSpaceKey key) {
         for (IdentifierSpaceHolder delegate : delegates) {
             ValueContext<?>  maybe = delegate.lookup(space, key);
             if(maybe != null) {
@@ -35,12 +35,12 @@ public ValueContext<?> lookup(AxiomIdentifier space, IdentifierSpaceKey key) {
     }
 
     @Override
-    public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
+    public void register(AxiomName space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
         export.register(space, scope, key, context);
     }
 
     @Override
-    public Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomIdentifier space) {
+    public Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomName space) {
         throw new UnsupportedOperationException();
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolder.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolder.java
index ee410c06c6d..4769db1e084 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolder.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolder.java
@@ -2,16 +2,16 @@
 
 import java.util.Map;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomIdentifierDefinition.Scope;
 import com.evolveum.axiom.lang.api.IdentifierSpaceKey;
 
 
 interface IdentifierSpaceHolder {
 
-    void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context);
+    void register(AxiomName space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context);
 
-    public ValueContext<?> lookup(AxiomIdentifier space, IdentifierSpaceKey key);
+    public ValueContext<?> lookup(AxiomName space, IdentifierSpaceKey key);
 
-    Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomIdentifier space);
+    Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomName space);
 }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolderImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolderImpl.java
index 92729bb93e7..63429613292 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolderImpl.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/IdentifierSpaceHolderImpl.java
@@ -6,7 +6,7 @@
 import java.util.Set;
 import java.util.Map.Entry;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.schema.AxiomIdentifierDefinition.Scope;
 import com.evolveum.axiom.lang.api.IdentifierSpaceKey;
@@ -17,14 +17,14 @@
 public class IdentifierSpaceHolderImpl implements IdentifierSpaceHolder {
 
     Set<Scope> allowedScopes;
-    Map<AxiomIdentifier, Map<IdentifierSpaceKey, ValueContext<?>>> space = new HashMap<>();
+    Map<AxiomName, Map<IdentifierSpaceKey, ValueContext<?>>> space = new HashMap<>();
 
     public IdentifierSpaceHolderImpl(Scope first, Scope... rest) {
         allowedScopes = EnumSet.of(first, rest);
     }
 
     @Override
-    public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key, ValueContext<?> item) {
+    public void register(AxiomName space, Scope scope, IdentifierSpaceKey key, ValueContext<?> item) {
         Preconditions.checkArgument(allowedScopes.contains(scope), "Scope " + scope + " is not allowed");// TODO
                                                                                                          // Auto-generated
                                                                                                          // method stub
@@ -34,19 +34,19 @@ public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key,
     }
 
     @Override
-    public ValueContext<?> lookup(AxiomIdentifier space, IdentifierSpaceKey key) {
+    public ValueContext<?> lookup(AxiomName space, IdentifierSpaceKey key) {
         return space(space).get(key);
     }
 
     @Override
-    public Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomIdentifier spaceId) {
+    public Map<IdentifierSpaceKey, ValueContext<?>> space(AxiomName spaceId) {
         return space.computeIfAbsent(spaceId, k -> new HashMap<>());
     }
 
-    Map<AxiomIdentifier, Map<IdentifierSpaceKey, AxiomValue<?>>> build() {
-        ImmutableMap.Builder<AxiomIdentifier, Map<IdentifierSpaceKey, AxiomValue<?>>> roots = ImmutableMap
+    Map<AxiomName, Map<IdentifierSpaceKey, AxiomValue<?>>> build() {
+        ImmutableMap.Builder<AxiomName, Map<IdentifierSpaceKey, AxiomValue<?>>> roots = ImmutableMap
                 .builder();
-        for (Entry<AxiomIdentifier, Map<IdentifierSpaceKey, ValueContext<?>>> entry : space.entrySet()) {
+        for (Entry<AxiomName, Map<IdentifierSpaceKey, ValueContext<?>>> entry : space.entrySet()) {
             ImmutableMap.Builder<IdentifierSpaceKey, AxiomValue<?>> space = ImmutableMap.builder();
             for (Entry<IdentifierSpaceKey, ValueContext<?>> item : entry.getValue().entrySet()) {
                 space.put(item.getKey(), item.getValue().get());
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemContext.java
index 56f22b9508f..1d8d37830d0 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemContext.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemContext.java
@@ -6,7 +6,7 @@
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
@@ -20,18 +20,18 @@
 
 public class ItemContext<V> extends AbstractContext<ValueContext<?>> implements AxiomItemContext<V>, Supplier<AxiomItem<V>>, Dependency<AxiomItem<V>>, ItemBuilder {
 
-    private final AxiomIdentifier name;
+    private final AxiomName name;
     Collection<Dependency<AxiomValue<V>>> values = new ArrayList<>();
     private final AxiomItemDefinition definition;
 
-    public ItemContext(ValueContext<?> sourceContext, AxiomIdentifier name, AxiomItemDefinition definition, SourceLocation loc) {
+    public ItemContext(ValueContext<?> sourceContext, AxiomName name, AxiomItemDefinition definition, SourceLocation loc) {
         super(sourceContext, loc, sourceContext);
         this.name = name;
         this.definition = definition;
     }
 
     @Override
-    public AxiomIdentifier name() {
+    public AxiomName name() {
         return name;
     }
 
@@ -52,7 +52,7 @@ public AxiomTypeDefinition type() {
     }
 
     @Override
-    protected Optional<AxiomItemDefinition> childDef(AxiomIdentifier id) {
+    protected Optional<AxiomItemDefinition> childDef(AxiomName id) {
         return type().itemDefinition(id);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemValueImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemValueImpl.java
index 414daead9eb..278f5427a0e 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemValueImpl.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ItemValueImpl.java
@@ -4,7 +4,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.AxiomValueFactory;
@@ -17,14 +17,14 @@ public class ItemValueImpl<V> implements AxiomValue<V> {
     private static final AxiomValueFactory FACTORY = ItemValueImpl::new;
     private final AxiomTypeDefinition type;
     private final V value;
-    private final Map<AxiomIdentifier, AxiomItem<?>> items;
+    private final Map<AxiomName, AxiomItem<?>> items;
 
 
     protected <X> X require(Optional<X> value) {
         return value.get();
     }
 
-    public ItemValueImpl(AxiomTypeDefinition type, V value, Map<AxiomIdentifier, AxiomItem<?>> items) {
+    public ItemValueImpl(AxiomTypeDefinition type, V value, Map<AxiomName, AxiomItem<?>> items) {
         super();
         this.type = type;
         this.value = value;
@@ -52,7 +52,7 @@ public Optional<AxiomItem<?>> item(AxiomItemDefinition def) {
     }
 
     @Override
-    public <T> Optional<AxiomItem<T>> item(AxiomIdentifier name) {
+    public <T> Optional<AxiomItem<T>> item(AxiomName name) {
         return Optional.ofNullable((AxiomItem<T>) items.get(name));
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ModelReactorContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ModelReactorContext.java
index b2dbf02e3bb..bc869dc0143 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ModelReactorContext.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ModelReactorContext.java
@@ -10,7 +10,7 @@
 
 import org.jetbrains.annotations.NotNull;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.AxiomValueFactory;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
@@ -38,7 +38,7 @@ public class ModelReactorContext extends
         RuleReactorContext<AxiomSemanticException, ValueContext<?>, ValueActionImpl<?>, RuleContextImpl>
         implements AxiomIdentifierResolver {
 
-    private static final AxiomIdentifier ROOT = AxiomIdentifier.from("root", "root");
+    private static final AxiomName ROOT = AxiomName.from("root", "root");
 
     private static final String AXIOM_LANG_RESOURCE = "/axiom-lang.axiom";
     private static final String AXIOM_BUILTIN_RESOURCE = "/axiom-base-types.axiom";
@@ -103,7 +103,7 @@ private static void defaults(ModelReactorContext reactorContext) {
 
     IdentifierSpaceHolderImpl globalSpace = new IdentifierSpaceHolderImpl(Scope.GLOBAL);
 
-    Map<AxiomIdentifier, AxiomValueFactory<?, ?>> typeFactories = new HashMap<>();
+    Map<AxiomName, AxiomValueFactory<?, ?>> typeFactories = new HashMap<>();
     List<AxiomValueContext<?>> roots = new ArrayList<>();
 
     public ModelReactorContext(AxiomSchemaContext boostrapContext) {
@@ -159,14 +159,14 @@ public void loadModelFromSource(AxiomModelStatementSource source) {
     }
 
     @Override
-    public AxiomIdentifier resolveIdentifier(@Nullable String prefix, @NotNull String localName) {
+    public AxiomName resolveIdentifier(@Nullable String prefix, @NotNull String localName) {
         if (Strings.isNullOrEmpty(prefix)) {
-            return AxiomIdentifier.axiom(localName);
+            return AxiomName.axiom(localName);
         }
         return null;
     }
 
-    public void addStatementFactory(AxiomIdentifier statementType, AxiomValueFactory<?, ?> factory) {
+    public void addStatementFactory(AxiomName statementType, AxiomValueFactory<?, ?> factory) {
         typeFactories.put(statementType, factory);
     }
 
@@ -192,7 +192,7 @@ private CompositeIdentifierSpace exported(IdentifierSpaceKey namespace) {
         return exported.computeIfAbsent(namespace, k -> new CompositeIdentifierSpace());
     }
 
-    public Dependency<NamespaceContext> namespace(AxiomIdentifier name, IdentifierSpaceKey namespaceId) {
+    public Dependency<NamespaceContext> namespace(AxiomName name, IdentifierSpaceKey namespaceId) {
         return Dependency.orNull(exported.get(namespaceId));
     }
 
@@ -207,7 +207,7 @@ protected Collection<RuleContextImpl> rulesFor(ValueContext<?> context) {
         return rules;
     }
 
-    public Optional<AxiomItemDefinition> rootDefinition(AxiomIdentifier statement) {
+    public Optional<AxiomItemDefinition> rootDefinition(AxiomName statement) {
         return boostrapContext.getRoot(statement);
     }
 
@@ -215,7 +215,7 @@ public void applyRuleDefinitions(ValueContext<?> valueContext) {
         addActionsFor(valueContext);
     }
 
-    public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
+    public void register(AxiomName space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
         globalSpace.register(space, scope, key, context);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/SourceContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/SourceContext.java
index 03f6d33acfb..95d84496f44 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/SourceContext.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/SourceContext.java
@@ -4,7 +4,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.AxiomValueFactory;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
@@ -21,11 +21,11 @@
 
 class SourceContext extends ValueContext<Void> implements AxiomRootContext, ValueBuilder {
 
-    private static final AxiomIdentifier ROOT = AxiomIdentifier.from("root", "root");
+    private static final AxiomName ROOT = AxiomName.from("root", "root");
 
     private final ModelReactorContext context;
     private final AxiomModelStatementSource source;
-    private final Map<AxiomIdentifier, ItemContext> items = new HashMap();
+    private final Map<AxiomName, ItemContext> items = new HashMap();
     private final CompositeIdentifierSpace globalSpace;
     private Map<String, String> imports;
 
@@ -38,17 +38,17 @@ public SourceContext(ModelReactorContext context, AxiomModelStatementSource sour
     }
 
     @Override
-    public AxiomIdentifier name() {
+    public AxiomName name() {
         return ROOT;
     }
 
     @Override
-    public ItemContext<?> startItem(AxiomIdentifier identifier, SourceLocation loc) {
+    public ItemContext<?> startItem(AxiomName identifier, SourceLocation loc) {
         return items.computeIfAbsent(identifier, id -> createItem(id, loc));
     }
 
     @Override
-    public Optional<AxiomItemDefinition> childDef(AxiomIdentifier statement) {
+    public Optional<AxiomItemDefinition> childDef(AxiomName statement) {
         return context.rootDefinition(statement);
     }
 
@@ -63,13 +63,13 @@ public void endValue(SourceLocation loc) {
     }
 
     @Override
-    public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
+    public void register(AxiomName space, Scope scope, IdentifierSpaceKey key, ValueContext<?> context) {
         globalSpace.register(space, scope, key, context);
         this.context.register(space, scope, key, context);
     }
 
     @Override
-    public ValueContext<?> lookup(AxiomIdentifier space, IdentifierSpaceKey key) {
+    public ValueContext<?> lookup(AxiomName space, IdentifierSpaceKey key) {
         return globalSpace.lookup(space, key);
     }
 
@@ -81,7 +81,7 @@ public void applyRuleDefinitions(ValueContext<?> valueContext) {
         context.applyRuleDefinitions(valueContext);
     }
 
-    public Dependency<NamespaceContext> requireNamespace(AxiomIdentifier name, IdentifierSpaceKey namespaceId) {
+    public Dependency<NamespaceContext> requireNamespace(AxiomName name, IdentifierSpaceKey namespaceId) {
         return Dependency.retriableDelegate(() -> {
             return context.namespace(name, namespaceId);
         });
@@ -102,13 +102,13 @@ public void exportIdentifierSpace(IdentifierSpaceKey namespaceId) {
     public AxiomIdentifierResolver itemResolver() {
         return (prefix, localName) -> {
             if(Strings.isNullOrEmpty(prefix)) {
-                AxiomIdentifier axiomNs = AxiomIdentifier.axiom(localName);
+                AxiomName axiomNs = AxiomName.axiom(localName);
                 if(childDef(axiomNs).isPresent()) {
                     return axiomNs;
                 }
             }
             String namespace = imports.get(prefix);
-            return AxiomIdentifier.from(namespace, localName);
+            return AxiomName.from(namespace, localName);
         };
     }
 
@@ -116,7 +116,7 @@ public AxiomIdentifierResolver itemResolver() {
     public AxiomIdentifierResolver valueResolver() {
         return AxiomIdentifierResolver.BUILTIN_TYPES.or((prefix, localName) -> {
             String namespace = imports.get(prefix);
-            return AxiomIdentifier.from(namespace, localName);
+            return AxiomName.from(namespace, localName);
         });
     }
 }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ValueContext.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ValueContext.java
index f4093abbaa8..065124c0918 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ValueContext.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/impl/ValueContext.java
@@ -13,7 +13,7 @@
 import java.util.Optional;
 import java.util.function.Supplier;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.AxiomValueBuilder;
@@ -50,7 +50,7 @@ public ValueContext(ItemContext<V> itemContext, V value, SourceLocation loc) {
     }
 
     @Override
-    public AxiomIdentifier name() {
+    public AxiomName name() {
         return parent().name();
     }
 
@@ -59,12 +59,12 @@ public LookupImpl getLookup() {
     }
 
     @Override
-    public Optional<AxiomItemDefinition> childDef(AxiomIdentifier statement) {
+    public Optional<AxiomItemDefinition> childDef(AxiomName statement) {
         return parent().type().itemDefinition(statement);
     }
 
     @Override
-    public ItemContext<?> startItem(AxiomIdentifier identifier, SourceLocation loc) {
+    public ItemContext<?> startItem(AxiomName identifier, SourceLocation loc) {
         return mutable().getOrCreateItem(Inheritance.adapt(parent().name(), identifier), loc);
     }
 
@@ -109,7 +109,7 @@ public ValueActionImpl<V> addAction(String name) {
         return new ValueActionImpl<>(this, name);
     }
 
-    protected ItemContext<?> createItem(AxiomIdentifier id, SourceLocation loc) {
+    protected ItemContext<?> createItem(AxiomName id, SourceLocation loc) {
         return new ItemContext<>(this, id ,childDef(id).get(), loc);
     }
 
@@ -125,7 +125,7 @@ public Result(AxiomTypeDefinition type, V value) {
             builder = AxiomValueBuilder.create(type, null);
         }
 
-        ItemContext<?> getOrCreateItem(AxiomIdentifier identifier, SourceLocation loc) {
+        ItemContext<?> getOrCreateItem(AxiomName identifier, SourceLocation loc) {
             return mutableItem(builder.get(identifier, id -> {
                 ItemContext<?> item = createItem(id, loc);
                 addDependency(item);
@@ -133,7 +133,7 @@ ItemContext<?> getOrCreateItem(AxiomIdentifier identifier, SourceLocation loc) {
             }));
         }
 
-        <T> Dependency<AxiomItem<T>> getItem(AxiomIdentifier item) {
+        <T> Dependency<AxiomItem<T>> getItem(AxiomName item) {
             Supplier<? extends AxiomItem<?>> maybeItem = builder.get(item);
             if(maybeItem == null) {
                 return null;
@@ -173,7 +173,7 @@ public void replace(AxiomValue<?> axiomItemValue) {
     }
 
     @Override
-    public <T> ItemContext<T> childItem(AxiomIdentifier name) {
+    public <T> ItemContext<T> childItem(AxiomName name) {
         return (ItemContext<T>) mutable().getOrCreateItem(Inheritance.adapt(parent().name(), name), SourceLocation.runtime());
     }
 
@@ -197,7 +197,7 @@ public void mergeItem(AxiomItem<?> axiomItem) {
     }
 
     @Override
-    public void register(AxiomIdentifier space, Scope scope, IdentifierSpaceKey key) {
+    public void register(AxiomName space, Scope scope, IdentifierSpaceKey key) {
         register(space, scope, key, this);
     }
 
@@ -217,7 +217,7 @@ public void dependsOnAction(ValueActionImpl<V> action) {
         addDependency(action);
     }
 
-    public <T> Dependency.Search<AxiomItem<T>> requireChild(AxiomIdentifier item) {
+    public <T> Dependency.Search<AxiomItem<T>> requireChild(AxiomName item) {
         return Dependency.retriableDelegate(() -> {
             if(result instanceof ValueContext.Result) {
                 return ((ValueContext.Result) result).getItem(item);
@@ -252,7 +252,7 @@ public AxiomItemDefinition itemDefinition() {
         }
 
         @Override
-        public Dependency<NamespaceContext> namespace(AxiomIdentifier name, IdentifierSpaceKey namespaceId) {
+        public Dependency<NamespaceContext> namespace(AxiomName name, IdentifierSpaceKey namespaceId) {
             return rootImpl().requireNamespace(name, namespaceId);
         }
 
@@ -291,7 +291,7 @@ public <T> Dependency<AxiomValue<T>> onlyItemValue(AxiomItemDefinition definitio
         }
 
         @Override
-        public Dependency<AxiomValueContext<?>> modify(AxiomIdentifier space, IdentifierSpaceKey key) {
+        public Dependency<AxiomValueContext<?>> modify(AxiomName space, IdentifierSpaceKey key) {
             return (Dependency.retriableDelegate(() -> {
                 ValueContext<?> maybe = lookup(space, key);
                 if(maybe != null) {
@@ -303,7 +303,7 @@ public Dependency<AxiomValueContext<?>> modify(AxiomIdentifier space, Identifier
         }
 
         @Override
-        public Dependency.Search<AxiomValue<?>> global(AxiomIdentifier space,
+        public Dependency.Search<AxiomValue<?>> global(AxiomName space,
                 IdentifierSpaceKey key) {
             return Dependency.retriableDelegate(() -> {
                 ValueContext<?> maybe = lookup(space, key);
@@ -315,7 +315,7 @@ public Dependency.Search<AxiomValue<?>> global(AxiomIdentifier space,
         }
 
         @Override
-        public Dependency.Search<AxiomValueReference<?>> reference(AxiomIdentifier space,
+        public Dependency.Search<AxiomValueReference<?>> reference(AxiomName space,
                 IdentifierSpaceKey key) {
             return Dependency.retriableDelegate(() -> {
                 ValueContext<?> maybe = lookup(space, key);
@@ -327,7 +327,7 @@ public Dependency.Search<AxiomValueReference<?>> reference(AxiomIdentifier space
         }
 
         @Override
-        public Dependency.Search<AxiomValue<?>> namespaceValue(AxiomIdentifier space,
+        public Dependency.Search<AxiomValue<?>> namespaceValue(AxiomName space,
                 IdentifierSpaceKey key) {
             return Dependency.retriableDelegate(() -> {
                 ValueContext<?> maybe = lookup(space, key);
@@ -373,14 +373,14 @@ public AxiomSemanticException error(String message, Object... arguments) {
     public AxiomIdentifierResolver itemResolver() {
         return (prefix, localName) -> {
             if(Strings.isNullOrEmpty(prefix)) {
-                AxiomIdentifier localNs = AxiomIdentifier.local(localName);
+                AxiomName localNs = AxiomName.local(localName);
                 Optional<AxiomItemDefinition> childDef = childDef(localNs);
                 if(childDef.isPresent()) {
                     return Inheritance.adapt(parent().name(), childDef.get());
                 }
                 ItemContext<?> parent = parent();
                 while(parent != null) {
-                    AxiomIdentifier parentNs = AxiomIdentifier.from(parent.name().namespace(), localName);
+                    AxiomName parentNs = AxiomName.from(parent.name().namespace(), localName);
                     if(childDef(parentNs).isPresent()) {
                         return parentNs;
                     }
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AbstractBaseDefinition.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AbstractBaseDefinition.java
index 97648959166..b3c1b80d7ee 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AbstractBaseDefinition.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AbstractBaseDefinition.java
@@ -2,7 +2,7 @@
 
 import java.util.Map;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.schema.AxiomNamedDefinition;
 import com.evolveum.axiom.api.schema.AxiomTypeDefinition;
@@ -11,17 +11,17 @@
 
 public class AbstractBaseDefinition<V> extends ItemValueImpl<V> implements AxiomNamedDefinition {
 
-    private final AxiomIdentifier name;
+    private final AxiomName name;
     private final  String documentation;
 
-    public AbstractBaseDefinition(AxiomTypeDefinition type, V value, Map<AxiomIdentifier, AxiomItem<?>> items) {
+    public AbstractBaseDefinition(AxiomTypeDefinition type, V value, Map<AxiomName, AxiomItem<?>> items) {
         super(type, value, items);
-        name = (AxiomIdentifier) item(Item.NAME).get().onlyValue().get();
+        name = (AxiomName) item(Item.NAME).get().onlyValue().get();
         documentation = item(Item.DOCUMENTATION).map(i -> i.onlyValue().get().toString()).orElse(null); //
     }
 
     @Override
-    public AxiomIdentifier name() {
+    public AxiomName name() {
         return name;
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierDefinitionImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierDefinitionImpl.java
index 688d0495a8f..db4dddd6f8f 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierDefinitionImpl.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierDefinitionImpl.java
@@ -2,7 +2,7 @@
 
 import java.util.Collection;
 import java.util.Map;
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.AxiomValueFactory;
@@ -21,12 +21,12 @@ public class AxiomIdentifierDefinitionImpl extends ItemValueImpl<AxiomIdentifier
     private final Scope scope;
     private final Collection<AxiomItemDefinition> components;
 
-    private final AxiomIdentifier space;
+    private final AxiomName space;
 
-    public AxiomIdentifierDefinitionImpl(AxiomTypeDefinition axiomItemDefinition, AxiomIdentifierDefinition value, Map<AxiomIdentifier, AxiomItem<?>> items) {
+    public AxiomIdentifierDefinitionImpl(AxiomTypeDefinition axiomItemDefinition, AxiomIdentifierDefinition value, Map<AxiomName, AxiomItem<?>> items) {
         super(axiomItemDefinition, value, items);
-        this.scope = AxiomIdentifierDefinition.scope(this.<AxiomIdentifier>item(Item.ID_SCOPE.name()).get().onlyValue().get().localName());
-        this.space = this.<AxiomIdentifier>item(Item.ID_SPACE.name()).get().onlyValue().get();
+        this.scope = AxiomIdentifierDefinition.scope(this.<AxiomName>item(Item.ID_SCOPE.name()).get().onlyValue().get().localName());
+        this.space = this.<AxiomName>item(Item.ID_SPACE.name()).get().onlyValue().get();
 
         ImmutableList.Builder<AxiomItemDefinition> components = ImmutableList.builder();
         for (AxiomValue<AxiomItemDefinition> val : this.<AxiomItemDefinition>item(Item.ID_MEMBER.name()).get().values()) {
@@ -51,7 +51,7 @@ public Scope scope() {
     }
 
     @Override
-    public AxiomIdentifier space() {
+    public AxiomName space() {
         return space;
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierResolver.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierResolver.java
index 47e1f9b057f..4e00a67981c 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierResolver.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomIdentifierResolver.java
@@ -11,7 +11,7 @@
 
 import org.jetbrains.annotations.NotNull;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.meta.Inheritance;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
 import com.evolveum.axiom.api.schema.AxiomTypeDefinition;
@@ -22,24 +22,24 @@
 
 public interface AxiomIdentifierResolver {
 
-    final AxiomIdentifierResolver AXIOM_DEFAULT_NAMESPACE =  defaultNamespace(AxiomIdentifier.AXIOM_NAMESPACE);
+    final AxiomIdentifierResolver AXIOM_DEFAULT_NAMESPACE =  defaultNamespace(AxiomName.AXIOM_NAMESPACE);
     final Set<String> BUILTINS = ImmutableSet.of("string","boolean","uri", "int", "binary", "dateTime");
     final AxiomIdentifierResolver BUILTIN_TYPES = (prefix, localName) -> {
         if((prefix == null || prefix.isEmpty()) && BUILTINS.contains(localName)) {
-            return AxiomIdentifier.axiom(localName);
+            return AxiomName.axiom(localName);
         }
         return null;
     };
 
-    AxiomIdentifier resolveIdentifier(@Nullable String prefix, @NotNull String localName);
+    AxiomName resolveIdentifier(@Nullable String prefix, @NotNull String localName);
 
     static AxiomIdentifierResolver defaultNamespace(String namespace) {
-        return (prefix, localName) -> Strings.isNullOrEmpty(prefix) ? AxiomIdentifier.from(namespace, localName) : null;
+        return (prefix, localName) -> Strings.isNullOrEmpty(prefix) ? AxiomName.from(namespace, localName) : null;
     }
 
     default AxiomIdentifierResolver or(AxiomIdentifierResolver next) {
         return (prefix, localName) -> {
-            AxiomIdentifier maybe = this.resolveIdentifier(prefix, localName);
+            AxiomName maybe = this.resolveIdentifier(prefix, localName);
             if (maybe != null) {
                 return maybe;
             }
@@ -50,7 +50,7 @@ default AxiomIdentifierResolver or(AxiomIdentifierResolver next) {
     static AxiomIdentifierResolver defaultNamespaceFromType(AxiomTypeDefinition type) {
         return (prefix, localName) -> {
             if(Strings.isNullOrEmpty(prefix)) {
-                AxiomIdentifier localNs = AxiomIdentifier.local(localName);
+                AxiomName localNs = AxiomName.local(localName);
                 Optional<AxiomItemDefinition> childDef = type.itemDefinition(localNs);
                 if(childDef.isPresent()) {
                     return Inheritance.adapt(type.name(), childDef.get());
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemDefinitionImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemDefinitionImpl.java
index 168416f6dd8..a95b1a420ed 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemDefinitionImpl.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemDefinitionImpl.java
@@ -3,7 +3,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.AxiomValueFactory;
@@ -17,7 +17,7 @@ public class AxiomItemDefinitionImpl extends AbstractBaseDefinition<AxiomItemDef
     private final AxiomValue<AxiomTypeDefinition> valueType;
     private final Optional<AxiomItem<String>> minOccurs;
 
-    public AxiomItemDefinitionImpl(AxiomTypeDefinition axiomItemDefinition, AxiomItemDefinition value, Map<AxiomIdentifier, AxiomItem<?>> items) {
+    public AxiomItemDefinitionImpl(AxiomTypeDefinition axiomItemDefinition, AxiomItemDefinition value, Map<AxiomName, AxiomItem<?>> items) {
         super(axiomItemDefinition, value, items);
         this.valueType = require(onlyValue(AxiomTypeDefinition.class,Item.TYPE_REFERENCE, Item.REF_TARGET));
         minOccurs = this.<String>item(Item.MIN_OCCURS.name());
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemStreamTreeBuilder.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemStreamTreeBuilder.java
index 3bc2a072331..46a1b5baabd 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemStreamTreeBuilder.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomItemStreamTreeBuilder.java
@@ -9,7 +9,7 @@
 import java.util.Deque;
 import java.util.LinkedList;
 import java.util.Optional;
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomItemDefinition;
 import com.evolveum.axiom.api.stream.AxiomItemStream;
 import com.evolveum.axiom.concepts.SourceLocation;
@@ -58,7 +58,7 @@ public void endValue(SourceLocation loc) {
     }
 
     @Override
-    public void startItem(AxiomIdentifier item, SourceLocation loc) {
+    public void startItem(AxiomName item, SourceLocation loc) {
         Optional<AxiomItemDefinition> childDef = value(current()).childDef(item);
         AxiomSyntaxException.check(childDef.isPresent(), loc , "Item %s not allowed in %s", item, current().name());
         offer(value(current()).startItem(item, loc));
@@ -70,7 +70,7 @@ public void endItem(SourceLocation loc) {
     }
 
     private interface Builder {
-        AxiomIdentifier name();
+        AxiomName name();
     }
 
     public interface ItemBuilder extends Builder {
@@ -80,8 +80,8 @@ public interface ItemBuilder extends Builder {
     }
 
     public interface ValueBuilder extends Builder {
-        Optional<AxiomItemDefinition> childDef(AxiomIdentifier statement);
-        ItemBuilder startItem(AxiomIdentifier identifier, SourceLocation loc);
+        Optional<AxiomItemDefinition> childDef(AxiomName statement);
+        ItemBuilder startItem(AxiomName identifier, SourceLocation loc);
         void endValue(SourceLocation loc);
     }
 
diff --git a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomTypeDefinitionImpl.java b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomTypeDefinitionImpl.java
index 5a7e38226ee..874a168ab89 100644
--- a/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomTypeDefinitionImpl.java
+++ b/infra/axiom/src/main/java/com/evolveum/axiom/lang/spi/AxiomTypeDefinitionImpl.java
@@ -4,7 +4,7 @@
 import java.util.Collections;
 import java.util.Map;
 import java.util.Optional;
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.AxiomValueFactory;
@@ -21,16 +21,16 @@ public class AxiomTypeDefinitionImpl extends AbstractBaseDefinition<AxiomTypeDef
 
     public static final AxiomValueFactory<AxiomTypeDefinition, AxiomTypeDefinition> FACTORY =AxiomTypeDefinitionImpl::new;
 
-    private final Map<AxiomIdentifier, AxiomItemDefinition> itemDefinitions;
+    private final Map<AxiomName, AxiomItemDefinition> itemDefinitions;
     private final Optional<AxiomTypeDefinition> superType;
     private final Optional<AxiomItemDefinition> argument;
     private final Collection<AxiomIdentifierDefinition> identifiers;
 
-    public AxiomTypeDefinitionImpl(AxiomTypeDefinition def, AxiomTypeDefinition value, Map<AxiomIdentifier, AxiomItem<?>> keywordMap) {
+    public AxiomTypeDefinitionImpl(AxiomTypeDefinition def, AxiomTypeDefinition value, Map<AxiomName, AxiomItem<?>> keywordMap) {
         super(def, null, keywordMap);
 
         //super(keyword, value, children, keywordMap);
-        ImmutableMap.Builder<AxiomIdentifier, AxiomItemDefinition> builder =  ImmutableMap.builder();
+        ImmutableMap.Builder<AxiomName, AxiomItemDefinition> builder =  ImmutableMap.builder();
         Optional<AxiomItem<AxiomItemDefinition>> itemDef = item(Item.ITEM_DEFINITION.name());
         if(itemDef.isPresent()) {
             supplyAll(name(),builder, itemDef.get().values());
@@ -39,7 +39,7 @@ public AxiomTypeDefinitionImpl(AxiomTypeDefinition def, AxiomTypeDefinition valu
 
         superType = onlyValue(AxiomTypeDefinition.class,Item.SUPERTYPE_REFERENCE, Item.REF_TARGET).map(v -> v.get());
 
-        argument = this.<AxiomIdentifier>item(Item.ARGUMENT.name()).flatMap(v -> itemDefinition(v.onlyValue().get()));
+        argument = this.<AxiomName>item(Item.ARGUMENT.name()).flatMap(v -> itemDefinition(v.onlyValue().get()));
         identifiers = upcast(this.<AxiomIdentifierDefinition>item(Item.IDENTIFIER_DEFINITION.name()).map(v -> v.values()).orElse(Collections.emptyList()));
     }
 
@@ -53,7 +53,7 @@ private <V extends AxiomValue<V>> Collection<V> upcast(Collection<AxiomValue<V>>
     }
 
     @Override
-    public <V> Optional<AxiomItem<V>> item(AxiomIdentifier name) {
+    public <V> Optional<AxiomItem<V>> item(AxiomName name) {
         return super.item(name);
     }
 
@@ -71,7 +71,7 @@ public Optional<AxiomTypeDefinition> superType() {
     }
 
     @Override
-    public Map<AxiomIdentifier, AxiomItemDefinition> itemDefinitions() {
+    public Map<AxiomName, AxiomItemDefinition> itemDefinitions() {
         return itemDefinitions;
     }
 
@@ -80,11 +80,11 @@ public Collection<AxiomIdentifierDefinition> identifierDefinitions() {
         return identifiers;
     }
 
-    private void supplyAll(AxiomIdentifier type, Builder<AxiomIdentifier, AxiomItemDefinition> builder,
+    private void supplyAll(AxiomName type, Builder<AxiomName, AxiomItemDefinition> builder,
             Collection<AxiomValue<AxiomItemDefinition>> values) {
         for(AxiomValue<AxiomItemDefinition> v : values) {
             AxiomItemDefinition val = v.get();
-            AxiomIdentifier name = Inheritance.adapt(type, val.name());
+            AxiomName name = Inheritance.adapt(type, val.name());
             builder.put(name, val);
         }
     }
diff --git a/infra/axiom/src/main/resources/axiom-lang.axiom b/infra/axiom/src/main/resources/axiom-lang.axiom
index a587e426606..733f004bdfe 100644
--- a/infra/axiom/src/main/resources/axiom-lang.axiom
+++ b/infra/axiom/src/main/resources/axiom-lang.axiom
@@ -76,7 +76,7 @@ model axiom-lang {
         argument prefix;
 
         item prefix {
-            type AxiomIdentifier;
+            type AxiomName;
         }
 
         item namespace {
@@ -96,7 +96,7 @@ model axiom-lang {
         argument name;
 
         item name {
-            type AxiomIdentifier;
+            type AxiomName;
         }
 
         item documentation {
@@ -118,7 +118,7 @@ model axiom-lang {
     type AxiomIdentifierDefinition {
          argument key;
          item key {
-            type AxiomIdentifier;
+            type AxiomName;
             minOccurs "1";
          }
          item scope {
@@ -126,7 +126,7 @@ model axiom-lang {
             minOccurs "1";
          }
          item space {
-            type AxiomIdentifier;
+            type AxiomName;
             minOccurs "1";
          }
     }
@@ -145,7 +145,7 @@ model axiom-lang {
         }
 
         item argument {
-            type AxiomIdentifier;
+            type AxiomName;
             documentation """
                 Name of item, which is target of short-form value declaration.
             """;
@@ -182,7 +182,7 @@ model axiom-lang {
 
         // TODO reconsider this - strictly speaking this is part of "global type+item definition combo"
         item itemName {
-            type AxiomIdentifier;
+            type AxiomName;
         }
 
         item item {
@@ -194,8 +194,7 @@ model axiom-lang {
         }
     }
 
-    // FIXME: Should be AxiomName
-    type AxiomIdentifier {
+    type AxiomName {
         documentation """
             Qualified name. Consists of namespace and local name.
         """;
@@ -258,7 +257,7 @@ model axiom-lang {
         argument name;
 
         item name {
-            type AxiomIdentifier;
+            type AxiomName;
             documentation """
                 Name of referenced type definition.
                 The value must be name of existing type definition, which is 
diff --git a/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomExtension.java b/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomExtension.java
index 0fe43d216b1..557d1d8670c 100644
--- a/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomExtension.java
+++ b/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomExtension.java
@@ -16,7 +16,7 @@
 
 import org.testng.annotations.Test;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.schema.AxiomSchemaContext;
 import com.evolveum.axiom.api.schema.AxiomTypeDefinition;
@@ -26,10 +26,10 @@
 
 public class TestAxiomExtension extends AbstractReactorTest {
 
-    private static final AxiomIdentifier PERSON = AxiomIdentifier.from("https://example.org", "Person");
-    private static final AxiomIdentifier STORAGE = AxiomIdentifier.from("https://example.org/extension", "type");
+    private static final AxiomName PERSON = AxiomName.from("https://example.org", "Person");
+    private static final AxiomName STORAGE = AxiomName.from("https://example.org/extension", "type");
 
-    private static final AxiomIdentifier PERSON_EXTENSION = AxiomIdentifier.from("https://schema.org", "SchemaOrgPerson");
+    private static final AxiomName PERSON_EXTENSION = AxiomName.from("https://schema.org", "SchemaOrgPerson");
     private static final String DIR = "multimodel/extension/";
     private static final String SCHEMA_ORG = DIR + "person-extension.axiom";
     private static final String BASE = DIR + "test-person.axiom";
@@ -52,7 +52,7 @@ public void axiomTestExtension() throws IOException, AxiomSyntaxException {
         Optional<AxiomTypeDefinition> extPersonDef = schemaContext.getType(PERSON_EXTENSION);
         assertTrue(extPersonDef.isPresent());
 
-        for(AxiomIdentifier item : extPersonDef.get().itemDefinitions().keySet()) {
+        for(AxiomName item : extPersonDef.get().itemDefinitions().keySet()) {
             assertTrue(personDef.get().itemDefinition(item).isPresent());
         }
     }
diff --git a/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomPrism.java b/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomPrism.java
index 21f7abee4ea..a60a32c94d9 100644
--- a/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomPrism.java
+++ b/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestAxiomPrism.java
@@ -11,17 +11,17 @@
 import java.io.IOException;
 import org.testng.annotations.Test;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.schema.AxiomSchemaContext;
 import com.evolveum.axiom.lang.impl.ModelReactorContext;
 import com.evolveum.axiom.lang.spi.AxiomSyntaxException;
 
 public class TestAxiomPrism extends AbstractReactorTest {
 
-    private static final AxiomIdentifier PERSON = AxiomIdentifier.from("https://example.org", "Person");
-    private static final AxiomIdentifier STORAGE = AxiomIdentifier.from("https://example.org/extension", "type");
+    private static final AxiomName PERSON = AxiomName.from("https://example.org", "Person");
+    private static final AxiomName STORAGE = AxiomName.from("https://example.org/extension", "type");
 
-    private static final AxiomIdentifier PERSON_EXTENSION = AxiomIdentifier.from("https://schema.org", "SchemaOrgPerson");
+    private static final AxiomName PERSON_EXTENSION = AxiomName.from("https://schema.org", "SchemaOrgPerson");
     private static final String DIR = "prism/";
     private static final String PRISM = DIR + "prism.axiom";
     private static final String COMMON_CORE = DIR + "common-core.axiom";
diff --git a/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestTypeDerivation.java b/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestTypeDerivation.java
index 81cd005cacb..a50bff4c9eb 100644
--- a/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestTypeDerivation.java
+++ b/infra/axiom/src/test/java/com/evolveum/axiom/lang/test/TestTypeDerivation.java
@@ -16,7 +16,7 @@
 
 import org.testng.annotations.Test;
 
-import com.evolveum.axiom.api.AxiomIdentifier;
+import com.evolveum.axiom.api.AxiomName;
 import com.evolveum.axiom.api.AxiomItem;
 import com.evolveum.axiom.api.AxiomValue;
 import com.evolveum.axiom.api.meta.Inheritance;
@@ -32,10 +32,10 @@
 
 public class TestTypeDerivation extends AbstractReactorTest {
 
-    private static final AxiomIdentifier DERIVED_PERSON = AxiomIdentifier.from("https://example.org/derived", "Person");
-    private static final AxiomIdentifier FIRST_NAME = DERIVED_PERSON.localName("firstName");
-    private static final AxiomIdentifier LAST_NAME = DERIVED_PERSON.localName("lastName");
-    private static final AxiomIdentifier NAME = AxiomIdentifier.from("https://example.org/base", "name");
+    private static final AxiomName DERIVED_PERSON = AxiomName.from("https://example.org/derived", "Person");
+    private static final AxiomName FIRST_NAME = DERIVED_PERSON.localName("firstName");
+    private static final AxiomName LAST_NAME = DERIVED_PERSON.localName("lastName");
+    private static final AxiomName NAME = AxiomName.from("https://example.org/base", "name");
     private static final String DIR = "multimodel/derived/";
     private static final String BASE = DIR + "base-person.axiom";
     private static final String DERIVED = DIR + "derived-person.axiom";
@@ -57,7 +57,7 @@ public void axiomTestInheritance() throws IOException, AxiomSyntaxException {
 
         Optional<AxiomTypeDefinition> personDef = schemaContext.getType(DERIVED_PERSON);
         assertTrue(personDef.isPresent());
-        for (Entry<AxiomIdentifier, AxiomItemDefinition> idDef : personDef.get().itemDefinitions().entrySet()) {
+        for (Entry<AxiomName, AxiomItemDefinition> idDef : personDef.get().itemDefinitions().entrySet()) {
             AxiomItemDefinition item = idDef.getValue();
             assertEquals(idDef.getKey(), Inheritance.adapt(DERIVED_PERSON, item), " should have different namespace");
         }