diff --git a/src/Microsoft.OData.Edm/Csdl/CsdlConstants.cs b/src/Microsoft.OData.Edm/Csdl/CsdlConstants.cs
index f711406245..4837056fe3 100644
--- a/src/Microsoft.OData.Edm/Csdl/CsdlConstants.cs
+++ b/src/Microsoft.OData.Edm/Csdl/CsdlConstants.cs
@@ -68,6 +68,7 @@ public static class CsdlConstants
         internal const string Attribute_DateTimeOffset = "DateTimeOffset";
         internal const string Attribute_Decimal = "Decimal";
         internal const string Attribute_DefaultValue = "DefaultValue";
+        internal const string Attribute_BaseTerm = "BaseTerm";
         internal const string Attribute_ElementType = "ElementType";
         internal const string Attribute_Extends = "Extends";
         internal const string Attribute_EntityType = "EntityType";
diff --git a/src/Microsoft.OData.Edm/Csdl/Parsing/Ast/CsdlTerm.cs b/src/Microsoft.OData.Edm/Csdl/Parsing/Ast/CsdlTerm.cs
index 84ebafa5ef..b881962ee8 100644
--- a/src/Microsoft.OData.Edm/Csdl/Parsing/Ast/CsdlTerm.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Parsing/Ast/CsdlTerm.cs
@@ -14,11 +14,13 @@ internal class CsdlTerm : CsdlNamedElement
         private readonly CsdlTypeReference type;
         private readonly string appliesTo;
         private readonly string defaultValue;
+        private readonly string baseTermName;
 
-        public CsdlTerm(string name, CsdlTypeReference type, string appliesTo, string defaultValue, CsdlLocation location)
+        public CsdlTerm(string name, CsdlTypeReference type, string baseTermName, string appliesTo, string defaultValue, CsdlLocation location)
             : base(name, location)
         {
             this.type = type;
+            this.baseTermName = baseTermName;
             this.appliesTo = appliesTo;
             this.defaultValue = defaultValue;
         }
@@ -28,6 +30,11 @@ public CsdlTypeReference Type
             get { return this.type; }
         }
 
+        public string BaseTermName
+        {
+            get { return this.baseTermName; }
+        }
+
         public string AppliesTo
         {
             get { return this.appliesTo; }
diff --git a/src/Microsoft.OData.Edm/Csdl/Parsing/CsdlDocumentParser.cs b/src/Microsoft.OData.Edm/Csdl/Parsing/CsdlDocumentParser.cs
index 8b1a8da4bd..231e139209 100644
--- a/src/Microsoft.OData.Edm/Csdl/Parsing/CsdlDocumentParser.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Parsing/CsdlDocumentParser.cs
@@ -509,8 +509,9 @@ private CsdlTerm OnTermElement(XmlElementInfo element, XmlElementValueCollection
             string name = Required(CsdlConstants.Attribute_Name);
             string appliesTo = Optional(CsdlConstants.Attribute_AppliesTo);
             string defaultValue = Optional(CsdlConstants.Attribute_DefaultValue);
+            string baseTerm = Optional(CsdlConstants.Attribute_BaseTerm);
 
-            return new CsdlTerm(name, type, appliesTo, defaultValue, element.Location);
+            return new CsdlTerm(name, type, baseTerm, appliesTo, defaultValue, element.Location);
         }
 
         private CsdlAnnotations OnAnnotationsElement(XmlElementInfo element, XmlElementValueCollection childValues)
diff --git a/src/Microsoft.OData.Edm/Csdl/Parsing/SchemaJsonParser.cs b/src/Microsoft.OData.Edm/Csdl/Parsing/SchemaJsonParser.cs
index 1915163cfe..a894699a51 100644
--- a/src/Microsoft.OData.Edm/Csdl/Parsing/SchemaJsonParser.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Parsing/SchemaJsonParser.cs
@@ -1084,6 +1084,7 @@ internal static CsdlTerm ParseCsdlTermType(string name, JsonElement element, Jso
 
             IList<string> appliesTo = null;
             string defaultValue = null;
+            string baseTerm = null;
             IList<CsdlAnnotation> termAnnotations = new List<CsdlAnnotation>();
             element.ParseAsObject(context, (propertyName, propertyValue) =>
             {
@@ -1103,8 +1104,7 @@ internal static CsdlTerm ParseCsdlTermType(string name, JsonElement element, Jso
 
                     case "$BaseTerm":
                         // The value of $BaseTerm is the qualified name of the base term.
-                        // Skip it because it's not supported
-                        context.ReportError(EdmErrorCode.UnexpectedElement, Strings.CsdlJsonParser_UnexpectedJsonMember(context.Path, element.ValueKind));
+                        baseTerm = propertyValue.ParseAsString(context);
                         break;
 
                     case "$DefaultValue":
@@ -1126,7 +1126,7 @@ internal static CsdlTerm ParseCsdlTermType(string name, JsonElement element, Jso
             });
 
             string appliesToStr = appliesTo != null ? string.Join(" ", appliesTo) : null;
-            CsdlTerm termType = new CsdlTerm(name, typeReference, appliesToStr, defaultValue, context.Location());
+            CsdlTerm termType = new CsdlTerm(name, typeReference, baseTerm, appliesToStr, defaultValue, context.Location());
             termAnnotations.ForEach(a => termType.AddAnnotation(a));
 
             return termType;
diff --git a/src/Microsoft.OData.Edm/Csdl/Semantics/BadElements/UnresolvedVocabularyTerm.cs b/src/Microsoft.OData.Edm/Csdl/Semantics/BadElements/UnresolvedVocabularyTerm.cs
index b947afed73..cce6c7bfeb 100644
--- a/src/Microsoft.OData.Edm/Csdl/Semantics/BadElements/UnresolvedVocabularyTerm.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Semantics/BadElements/UnresolvedVocabularyTerm.cs
@@ -51,6 +51,11 @@ public IEdmTypeReference Type
             get { return this.type; }
         }
 
+        public IEdmTerm BaseTerm
+        {
+            get { return null; }
+        }
+
         public string AppliesTo
         {
             get { return this.appliesTo; }
diff --git a/src/Microsoft.OData.Edm/Csdl/Semantics/CsdlSemanticsTerm.cs b/src/Microsoft.OData.Edm/Csdl/Semantics/CsdlSemanticsTerm.cs
index 1ba02417ec..ec960757de 100644
--- a/src/Microsoft.OData.Edm/Csdl/Semantics/CsdlSemanticsTerm.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Semantics/CsdlSemanticsTerm.cs
@@ -24,6 +24,9 @@ internal class CsdlSemanticsTerm : CsdlSemanticsElement, IEdmTerm, IEdmFullNamed
 
         private readonly Cache<CsdlSemanticsTerm, IEdmTypeReference> typeCache = new Cache<CsdlSemanticsTerm, IEdmTypeReference>();
         private static readonly Func<CsdlSemanticsTerm, IEdmTypeReference> ComputeTypeFunc = (me) => me.ComputeType();
+        private readonly Cache<CsdlSemanticsTerm, IEdmTerm> baseTermCache = new Cache<CsdlSemanticsTerm, IEdmTerm>();
+        private static readonly Func<CsdlSemanticsTerm, IEdmTerm> ComputeBaseTermFunc = (me) => me.ComputeBaseTerm();
+        private static readonly Func<CsdlSemanticsTerm, IEdmTerm> OnCycleBaseTermFunc = (me) => new CyclicTerm(me.GetCyclicBaseTermName(me.term.BaseTermName), me.Location);
 
         public CsdlSemanticsTerm(CsdlSemanticsSchema context, CsdlTerm valueTerm)
             : base(valueTerm)
@@ -61,6 +64,11 @@ public IEdmTypeReference Type
             get { return this.typeCache.GetValue(this, ComputeTypeFunc, null); }
         }
 
+        public IEdmTerm BaseTerm
+        {
+            get { return this.baseTermCache.GetValue(this, ComputeBaseTermFunc, OnCycleBaseTermFunc); }
+        }
+
         public string AppliesTo
         {
             get { return this.term.AppliesTo; }
@@ -90,5 +98,31 @@ private IEdmTypeReference ComputeType()
         {
             return CsdlSemanticsModel.WrapTypeReference(this.Context, this.term.Type);
         }
+
+        private IEdmTerm ComputeBaseTerm()
+        {
+            if (this.term.BaseTermName != null)
+            {
+                IEdmTerm baseTerm = this.Context.FindTerm(this.term.BaseTermName);
+                if (baseTerm != null)
+                {
+                    // Evaluate the inductive step to detect cycles.
+                    // Overriding BaseTerm getter from concrete type implementing IEdmTerm will be invoked to
+                    // detect cycles. The object assignment is required by compiler only.
+                    IEdmTerm baseTerm2 = baseTerm.BaseTerm;
+                }
+
+                return baseTerm ?? new UnresolvedVocabularyTerm(this.term.BaseTermName);
+            }
+
+            return null;
+        }
+
+        // Resolves the real name of the base term, in case it was using an alias before.
+        protected string GetCyclicBaseTermName(string baseTermName)
+        {
+            IEdmTerm schemaBaseTerm = this.Context.FindTerm(baseTermName);
+            return (schemaBaseTerm != null) ? schemaBaseTerm.FullName() : baseTermName;
+        }
     }
 }
diff --git a/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaJsonWriter.cs b/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaJsonWriter.cs
index 212930e44e..5257a27d4a 100644
--- a/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaJsonWriter.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaJsonWriter.cs
@@ -79,7 +79,8 @@ internal override void WriteTermElementHeader(IEdmTerm term, bool inlineType)
             }
 
             // A term MAY specialize another term in scope by specifying it as its base term.
-            // The value of $BaseTerm is the qualified name of the base term. So far, it's not supported.
+            // The value of $BaseTerm is the qualified name of the base term.
+            this.jsonWriter.WriteOptionalProperty("$BaseTerm", term.BaseTerm, this.SerializationName);
 
             // It MAY contain the members $AppliesTo.
             // The value of $AppliesTo is an array whose items are strings containing symbolic values from a table
diff --git a/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaXmlWriter.cs b/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaXmlWriter.cs
index 09ccae1f10..4af1c780a2 100644
--- a/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaXmlWriter.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelCsdlSchemaXmlWriter.cs
@@ -67,6 +67,8 @@ internal override void WriteTermElementHeader(IEdmTerm term, bool inlineType)
                 this.WriteRequiredAttribute(CsdlConstants.Attribute_Type, term.Type, this.TypeReferenceAsXml);
             }
 
+            this.WriteOptionalAttribute(CsdlConstants.Attribute_BaseTerm, term.BaseTerm, this.SerializationName);
+
             this.WriteOptionalAttribute(CsdlConstants.Attribute_DefaultValue, term.DefaultValue, EdmValueWriter.StringAsXml);
             this.WriteOptionalAttribute(CsdlConstants.Attribute_AppliesTo, term.AppliesTo, EdmValueWriter.StringAsXml);
         }
diff --git a/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelSchemaSeparationSerializationVisitor.cs b/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelSchemaSeparationSerializationVisitor.cs
index 34c7480016..be0d4d8be6 100644
--- a/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelSchemaSeparationSerializationVisitor.cs
+++ b/src/Microsoft.OData.Edm/Csdl/Serialization/EdmModelSchemaSeparationSerializationVisitor.cs
@@ -164,6 +164,15 @@ protected override void ProcessComplexType(IEdmComplexType element)
             }
         }
 
+        protected override void ProcessTerm(IEdmTerm element)
+        {
+            base.ProcessTerm(element);
+            if (element.BaseTerm != null)
+            {
+                this.CheckSchemaElementReference(element.BaseTerm);
+            }
+        }
+
         protected override void ProcessEnumType(IEdmEnumType element)
         {
             base.ProcessEnumType(element);
diff --git a/src/Microsoft.OData.Edm/Microsoft.OData.Edm.cs b/src/Microsoft.OData.Edm/Microsoft.OData.Edm.cs
index b3c3ac4094..83ed147ed9 100644
--- a/src/Microsoft.OData.Edm/Microsoft.OData.Edm.cs
+++ b/src/Microsoft.OData.Edm/Microsoft.OData.Edm.cs
@@ -304,6 +304,7 @@ internal sealed class EdmRes {
         internal const string Bad_CyclicComplex = "Bad_CyclicComplex";
         internal const string Bad_CyclicEntityContainer = "Bad_CyclicEntityContainer";
         internal const string Bad_UnresolvedNavigationPropertyPath = "Bad_UnresolvedNavigationPropertyPath";
+        internal const string Bad_CyclicTerm = "Bad_CyclicTerm";
         internal const string RuleSet_DuplicateRulesExistInRuleSet = "RuleSet_DuplicateRulesExistInRuleSet";
         internal const string EdmToClr_UnsupportedType = "EdmToClr_UnsupportedType";
         internal const string EdmToClr_StructuredValueMappedToNonClass = "EdmToClr_StructuredValueMappedToNonClass";
diff --git a/src/Microsoft.OData.Edm/Microsoft.OData.Edm.txt b/src/Microsoft.OData.Edm/Microsoft.OData.Edm.txt
index bdaa46b2e5..776d55b768 100644
--- a/src/Microsoft.OData.Edm/Microsoft.OData.Edm.txt
+++ b/src/Microsoft.OData.Edm/Microsoft.OData.Edm.txt
@@ -307,6 +307,7 @@ Bad_CyclicEntity=The entity '{0}' is invalid because its base type is cyclic.
 Bad_CyclicComplex=The complex type '{0}' is invalid because its base type is cyclic.
 Bad_CyclicEntityContainer=The entity container '{0}' is invalid because its extends hierarchy is cyclic.
 Bad_UnresolvedNavigationPropertyPath=A navigation property could not be found for the path '{0}' starting from the type '{1}'.
+Bad_CyclicTerm=The term '{0}' is invalid because its base type is cyclic.
 
 ; Error messages for validation rulesets
 RuleSet_DuplicateRulesExistInRuleSet=The same rule cannot be in the same rule set twice.
diff --git a/src/Microsoft.OData.Edm/Parameterized.Microsoft.OData.Edm.cs b/src/Microsoft.OData.Edm/Parameterized.Microsoft.OData.Edm.cs
index 8e1dc1aec8..17964fcd84 100644
--- a/src/Microsoft.OData.Edm/Parameterized.Microsoft.OData.Edm.cs
+++ b/src/Microsoft.OData.Edm/Parameterized.Microsoft.OData.Edm.cs
@@ -1583,7 +1583,7 @@ internal static string Serializer_SingleFileExpected
         /// A string like "Unknown Edm version '{0}'."
         /// </summary>
         internal static string Serializer_UnknownEdmVersion(object p0)
-		{
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.Serializer_UnknownEdmVersion, p0);
         }
 
@@ -1591,7 +1591,7 @@ internal static string Serializer_UnknownEdmVersion(object p0)
         /// A string like "Unknown Edmx version '{0}'."
         /// </summary>
         internal static string Serializer_UnknownEdmxVersion(object p0)
-		{
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.Serializer_UnknownEdmxVersion, p0);
         }
 
@@ -1955,77 +1955,88 @@ internal static string CsdlSemantics_DuplicateAlias(object p0, object p1)
         /// <summary>
         /// A string like "An unexpected '{0}' value kind was found when parsing the JSON path '{1}'. A '{2}' value kind was expected."
         /// </summary>
-        internal static string CsdlJsonParser_UnexpectedJsonValueKind(object p0, object p1, object p2) {
+        internal static string CsdlJsonParser_UnexpectedJsonValueKind(object p0, object p1, object p2)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_UnexpectedJsonValueKind, p0, p1, p2);
         }
 
         /// <summary>
         /// A string like "A member '{0}' is missing when parsing the JSON path '{1}'."
         /// </summary>
-        internal static string CsdlJsonParser_MissingMemberInObject(object p0, object p1) {
+        internal static string CsdlJsonParser_MissingMemberInObject(object p0, object p1)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_MissingMemberInObject, p0, p1);
         }
 
         /// <summary>
         /// A string like "A member '{0}' with value type '{1}' is unexpected."
         /// </summary>
-        internal static string CsdlJsonParser_UnexpectedJsonMember(object p0, object p1) {
+        internal static string CsdlJsonParser_UnexpectedJsonMember(object p0, object p1)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_UnexpectedJsonMember, p0, p1);
         }
 
         /// <summary>
         /// A string like "Cannot read the value '{0}' at JSON path '{1}' as '{2}' numeric value."
         /// </summary>
-        internal static string CsdlJsonParser_CannotReadValueAsType(object p0, object p1, object p2) {
+        internal static string CsdlJsonParser_CannotReadValueAsType(object p0, object p1, object p2)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_CannotReadValueAsType, p0, p1, p2);
         }
 
         /// <summary>
         /// A string like "A schema '{0}' object MUST contain the member '$Kind' with a string value of '{1}'."
         /// </summary>
-        internal static string CsdlJsonParser_MissingKindMember(object p0, object p1) {
+        internal static string CsdlJsonParser_MissingKindMember(object p0, object p1)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_MissingKindMember, p0, p1);
         }
 
         /// <summary>
         /// A string like "A property '{0}' is missing when parsing the JSON path '{1}'."
         /// </summary>
-        internal static string CsdlJsonParser_MissingRequiredPropertyInObject(object p0, object p1) {
+        internal static string CsdlJsonParser_MissingRequiredPropertyInObject(object p0, object p1)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_MissingRequiredPropertyInObject, p0, p1);
         }
 
         /// <summary>
         /// A string like "Found an unknown value kind '{0}' when parsing the JSON path '{1}'."
         /// </summary>
-        internal static string CsdlJsonParser_UnknownJsonElementValueKind(object p0, object p1) {
+        internal static string CsdlJsonParser_UnknownJsonElementValueKind(object p0, object p1)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_UnknownJsonElementValueKind, p0, p1);
         }
 
         /// <summary>
         /// A string like "Cannot parse a JSON number '{0}' when parsing the JSON path '{1}'."
         /// </summary>
-        internal static string CsdlJsonParser_InvalidJsonNumberType(object p0, object p1) {
+        internal static string CsdlJsonParser_InvalidJsonNumberType(object p0, object p1)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_InvalidJsonNumberType, p0, p1);
         }
 
         /// <summary>
         /// A string like "A member at JSON path '{0}' is not supported."
         /// </summary>
-        internal static string CsdlJsonParser_UnsupportedJsonMember(object p0) {
+        internal static string CsdlJsonParser_UnsupportedJsonMember(object p0)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_UnsupportedJsonMember, p0);
         }
 
         /// <summary>
         /// A string like "The version specified at '{0}' is not valid. It should be a string containing either '4.0' or '4.01'."
         /// </summary>
-        internal static string CsdlJsonParser_InvalidCsdlVersion(object p0) {
+        internal static string CsdlJsonParser_InvalidCsdlVersion(object p0)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_InvalidCsdlVersion, p0);
         }
 
         /// <summary>
         /// A string like "The schema object at '{0}' cannot have more than one entity container."
         /// </summary>
-        internal static string CsdlJsonParser_SchemaCannotHaveMoreThanOneEntityContainer(object p0) {
+        internal static string CsdlJsonParser_SchemaCannotHaveMoreThanOneEntityContainer(object p0)
+        {
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.CsdlJsonParser_SchemaCannotHaveMoreThanOneEntityContainer, p0);
         }
 
@@ -2422,6 +2433,14 @@ internal static string Bad_UnresolvedNavigationPropertyPath(object p0, object p1
             return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.Bad_UnresolvedNavigationPropertyPath, p0, p1);
         }
 
+        /// <summary>
+        /// A string like "The term '{0}' is invalid because its base type is cyclic."
+        /// </summary>
+        internal static string Bad_CyclicTerm(object p0)
+        {
+            return Microsoft.OData.Edm.EdmRes.GetString(Microsoft.OData.Edm.EdmRes.Bad_CyclicTerm, p0);
+        }
+
         /// <summary>
         /// A string like "The same rule cannot be in the same rule set twice."
         /// </summary>
diff --git a/src/Microsoft.OData.Edm/Schema/AmbiguousTermBinding.cs b/src/Microsoft.OData.Edm/Schema/AmbiguousTermBinding.cs
index 5fdadae305..e2e6040743 100644
--- a/src/Microsoft.OData.Edm/Schema/AmbiguousTermBinding.cs
+++ b/src/Microsoft.OData.Edm/Schema/AmbiguousTermBinding.cs
@@ -55,6 +55,11 @@ public IEdmTypeReference Type
             get { return this.type.GetValue(this, ComputeTypeFunc, null); }
         }
 
+        public IEdmTerm BaseTerm
+        {
+            get { return null; }
+        }
+
         public string AppliesTo
         {
             get { return this.appliesTo; }
diff --git a/src/Microsoft.OData.Edm/Schema/CyclicTerm.cs b/src/Microsoft.OData.Edm/Schema/CyclicTerm.cs
new file mode 100644
index 0000000000..7e2c6fc933
--- /dev/null
+++ b/src/Microsoft.OData.Edm/Schema/CyclicTerm.cs
@@ -0,0 +1,22 @@
+//---------------------------------------------------------------------
+// <copyright file="CyclicTerm.cs" company="Microsoft">
+//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+// </copyright>
+//---------------------------------------------------------------------
+
+using Microsoft.OData.Edm.Validation;
+using Microsoft.OData.Edm.Vocabularies;
+
+namespace Microsoft.OData.Edm
+{
+    /// <summary>
+    /// Represents an EDM term that cannot be determined due to a cyclic reference.
+    /// </summary>
+    internal class CyclicTerm : BadTerm
+    {
+        public CyclicTerm(string qualifiedName, EdmLocation location)
+            : base(qualifiedName, new EdmError[] { new EdmError(location, EdmErrorCode.BadCyclicTerm, Edm.Strings.Bad_CyclicTerm(qualifiedName)) })
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Microsoft.OData.Edm/Validation/EdmErrorCode.cs b/src/Microsoft.OData.Edm/Validation/EdmErrorCode.cs
index 82b448e9a4..ea146430ee 100644
--- a/src/Microsoft.OData.Edm/Validation/EdmErrorCode.cs
+++ b/src/Microsoft.OData.Edm/Validation/EdmErrorCode.cs
@@ -1383,6 +1383,11 @@ public enum EdmErrorCode
         /// </summary>
         AnnotationApplyToNotAllowedAnnotatable = 400,
 
+        /// <summary>
+        /// This ter, type is part of a cycle.
+        /// </summary>
+        BadCyclicTerm,
+
         /// <summary>
         /// Invalid $Key value.
         /// </summary>
diff --git a/src/Microsoft.OData.Edm/Vocabularies/Annotations/BadTerm.cs b/src/Microsoft.OData.Edm/Vocabularies/Annotations/BadTerm.cs
new file mode 100644
index 0000000000..f5f1210058
--- /dev/null
+++ b/src/Microsoft.OData.Edm/Vocabularies/Annotations/BadTerm.cs
@@ -0,0 +1,70 @@
+//---------------------------------------------------------------------
+// <copyright file="BadTerm.cs" company="Microsoft">
+//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+// </copyright>
+//---------------------------------------------------------------------
+
+using System.Collections.Generic;
+using Microsoft.OData.Edm.Validation;
+
+namespace Microsoft.OData.Edm.Vocabularies
+{
+    /// <summary>
+    /// Represents a semantically invalid EDM Term.
+    /// </summary>
+    internal class BadTerm : BadElement, IEdmTerm
+    {
+        private readonly string namespaceName;
+        private readonly string name;
+        private readonly string fullName;
+        private readonly IEdmTypeReference type;
+
+        public BadTerm(string qualifiedName, IEnumerable<EdmError> errors)
+            : base(errors)
+        {
+            qualifiedName = qualifiedName ?? string.Empty;
+            EdmUtil.TryGetNamespaceNameFromQualifiedName(qualifiedName, out this.namespaceName, out this.name, out this.fullName);
+            type = new BadTypeReference(new BadType(errors), true);
+        }
+
+        public string Name
+        {
+            get { return this.name; }
+        }
+
+        public string Namespace
+        {
+            get { return this.namespaceName; }
+        }
+
+        public string FullName
+        {
+            get { return this.fullName; }
+        }
+
+        public IEdmTypeReference Type
+        {
+            get { return this.type; }
+        }
+
+        public string AppliesTo
+        {
+            get { return null; }
+        }
+
+        public string DefaultValue
+        {
+            get { return null; }
+        }
+
+        public IEdmTerm BaseTerm
+        {
+            get { return null; }
+        }
+
+        public EdmSchemaElementKind SchemaElementKind
+        {
+            get { return EdmSchemaElementKind.Term; }
+        }
+    }
+}
diff --git a/src/Microsoft.OData.Edm/Vocabularies/Annotations/EdmTerm.cs b/src/Microsoft.OData.Edm/Vocabularies/Annotations/EdmTerm.cs
index 020aa76b53..d94122ffe6 100644
--- a/src/Microsoft.OData.Edm/Vocabularies/Annotations/EdmTerm.cs
+++ b/src/Microsoft.OData.Edm/Vocabularies/Annotations/EdmTerm.cs
@@ -16,6 +16,7 @@ public class EdmTerm : EdmNamedElement, IEdmTerm, IEdmFullNamedElement
         private readonly IEdmTypeReference type;
         private readonly string appliesTo;
         private readonly string defaultValue;
+        private readonly IEdmTerm baseTerm;
 
         /// <summary>
         /// Initializes a new instance of <see cref="EdmTerm"/> class.
@@ -49,7 +50,19 @@ public EdmTerm(string namespaceName, string name, EdmPrimitiveTypeKind type, str
         /// <param name="name">Name of the term.</param>
         /// <param name="type">Type of the term.</param>
         public EdmTerm(string namespaceName, string name, IEdmTypeReference type)
-            : this(namespaceName, name, type, null)
+            : this(namespaceName, name, type, baseTerm: null, appliesTo: null, defaultValue: null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EdmTerm"/> class.
+        /// </summary>
+        /// <param name="namespaceName">Namespace of the term.</param>
+        /// <param name="name">Name of the term.</param>
+        /// <param name="type">Type of the term.</param>
+        /// <param name="baseTerm">Base term of the term.</param>
+        public EdmTerm(string namespaceName, string name, IEdmTypeReference type, IEdmTerm baseTerm)
+            : this(namespaceName, name, type, baseTerm, appliesTo: null, defaultValue: null)
         {
         }
 
@@ -74,6 +87,20 @@ public EdmTerm(string namespaceName, string name, IEdmTypeReference type, string
         /// <param name="appliesTo">AppliesTo of the term.</param>
         /// <param name="defaultValue">DefaultValue of the term.</param>
         public EdmTerm(string namespaceName, string name, IEdmTypeReference type, string appliesTo, string defaultValue)
+            : this(namespaceName, name, type, baseTerm: null, appliesTo: appliesTo, defaultValue: defaultValue)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EdmTerm"/> class.
+        /// </summary>
+        /// <param name="namespaceName">Namespace of the term.</param>
+        /// <param name="name">Name of the term.</param>
+        /// <param name="type">Type of the term.</param>
+        /// <param name="baseTerm">Base term of the term.</param>
+        /// <param name="appliesTo">AppliesTo of the term.</param>
+        /// <param name="defaultValue">DefaultValue of the term.</param>
+        public EdmTerm(string namespaceName, string name, IEdmTypeReference type, IEdmTerm baseTerm, string appliesTo, string defaultValue)
             : base(name)
         {
             EdmUtil.CheckArgumentNull(namespaceName, "namespaceName");
@@ -81,6 +108,7 @@ public EdmTerm(string namespaceName, string name, IEdmTypeReference type, string
 
             this.namespaceName = namespaceName;
             this.type = type;
+            this.baseTerm = baseTerm;
             this.appliesTo = appliesTo;
             this.defaultValue = defaultValue;
             this.fullName = EdmUtil.GetFullNameForSchemaElement(this.namespaceName, this.Name);
@@ -126,6 +154,14 @@ public string DefaultValue
             get { return this.defaultValue; }
         }
 
+        /// <summary>
+        /// Gets the base term of this term.
+        /// </summary>
+        public IEdmTerm BaseTerm
+        {
+            get { return this.baseTerm; }
+        }
+
         /// <summary>
         /// Gets the schema element kind of this term.
         /// </summary>
diff --git a/src/Microsoft.OData.Edm/Vocabularies/Annotations/IEdmTerm.cs b/src/Microsoft.OData.Edm/Vocabularies/Annotations/IEdmTerm.cs
index ce12620172..8b9127eafe 100644
--- a/src/Microsoft.OData.Edm/Vocabularies/Annotations/IEdmTerm.cs
+++ b/src/Microsoft.OData.Edm/Vocabularies/Annotations/IEdmTerm.cs
@@ -25,5 +25,10 @@ public interface IEdmTerm : IEdmSchemaElement
         /// Gets the DefaultValue of this term.
         /// </summary>
         string DefaultValue { get; }
+
+        /// <summary>
+        /// Gets the base term of this term.
+        /// </summary>
+        IEdmTerm BaseTerm { get; }
     }
 }
diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs
index 1a9d523975..b79b729005 100644
--- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/CsdlWriterTests.cs
@@ -1850,6 +1850,130 @@ public void ShouldWriteAnnotationForEnumMember()
 }");
         }
 
+        [Fact]
+        public void ShouldWriteAnnotationUsingTermWithBaseTerm()
+        {
+            // Arrange
+            IEdmTypeReference propertyPathType = EdmCoreModel.Instance.GetPropertyPath(false);
+
+            EdmModel model = new EdmModel();
+
+            // Complex types
+            EdmComplexType aggreRecursiveHierarchyType = new EdmComplexType("Aggregation", "RecursiveHierarchyType");
+            aggreRecursiveHierarchyType.AddStructuralProperty("NodeProperty", propertyPathType);
+            aggreRecursiveHierarchyType.AddStructuralProperty("ParentNavigationProperty", EdmCoreModel.Instance.GetNavigationPropertyPath(false));
+            model.AddElement(aggreRecursiveHierarchyType);
+
+            EdmComplexType commonRecursiveHierarchyType = new EdmComplexType("Common", "RecursiveHierarchyType");
+            commonRecursiveHierarchyType.AddStructuralProperty("ExternalNodeKeyProperty", propertyPathType);
+            commonRecursiveHierarchyType.AddStructuralProperty("NodeDrillStateProperty", propertyPathType);
+            model.AddElement(commonRecursiveHierarchyType);
+
+            // Terms
+            EdmTerm baseTerm = new EdmTerm("Aggregation", "RecursiveHierarchy", new EdmComplexTypeReference(aggreRecursiveHierarchyType, true));
+            model.AddElement(baseTerm);
+            EdmTerm subTerm = new EdmTerm("Common", "RecursiveHierarchy", new EdmComplexTypeReference(commonRecursiveHierarchyType, true), baseTerm);
+            model.AddElement(subTerm);
+
+            // Enum
+            EdmEnumType appliance = new EdmEnumType("NS", "Appliance", EdmPrimitiveTypeKind.Int64, isFlags: true);
+            model.AddElement(appliance);
+
+            // Annotation
+            EdmRecordExpression record = new EdmRecordExpression(
+                new EdmPropertyConstructor("NodeProperty", new EdmPropertyPathExpression("a/b/c")),
+                new EdmPropertyConstructor("ParentNavigationProperty", new EdmNavigationPropertyPathExpression("e/f/g")),
+                new EdmPropertyConstructor("ExternalNodeKeyProperty", new EdmPropertyPathExpression("opq")),
+                new EdmPropertyConstructor("NodeDrillStateProperty", new EdmPropertyPathExpression("x/y/z")));
+
+            EdmVocabularyAnnotation annotation = new EdmVocabularyAnnotation(appliance, subTerm, record);
+            annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
+            model.SetVocabularyAnnotation(annotation);
+
+            WriteAndVerifyXml(model, "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
+              "<edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\">" +
+                "<edmx:DataServices>" +
+                  "<Schema Namespace=\"Aggregation\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">" +
+                    "<ComplexType Name=\"RecursiveHierarchyType\">" +
+                      "<Property Name=\"NodeProperty\" Type=\"Edm.PropertyPath\" Nullable=\"false\" />" +
+                      "<Property Name=\"ParentNavigationProperty\" Type=\"Edm.NavigationPropertyPath\" Nullable=\"false\" />" +
+                    "</ComplexType>" +
+                    "<Term Name=\"RecursiveHierarchy\" Type=\"Aggregation.RecursiveHierarchyType\" />" +
+                    "</Schema>" +
+                  "<Schema Namespace=\"Common\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">" +
+                    "<ComplexType Name=\"RecursiveHierarchyType\">" +
+                      "<Property Name=\"ExternalNodeKeyProperty\" Type=\"Edm.PropertyPath\" Nullable=\"false\" />" +
+                      "<Property Name=\"NodeDrillStateProperty\" Type=\"Edm.PropertyPath\" Nullable=\"false\" />" +
+                    "</ComplexType>" +
+                    "<Term Name=\"RecursiveHierarchy\" Type=\"Common.RecursiveHierarchyType\" BaseTerm=\"Aggregation.RecursiveHierarchy\" />" +
+                  "</Schema>" +
+                  "<Schema Namespace=\"NS\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">" +
+                    "<EnumType Name=\"Appliance\" UnderlyingType=\"Edm.Int64\" IsFlags=\"true\">" +
+                      "<Annotation Term=\"Common.RecursiveHierarchy\">" +
+                        "<Record>" +
+                          "<PropertyValue Property=\"NodeProperty\" PropertyPath=\"a/b/c\" />" +
+                          "<PropertyValue Property=\"ParentNavigationProperty\" NavigationPropertyPath=\"e/f/g\" />" +
+                          "<PropertyValue Property=\"ExternalNodeKeyProperty\" PropertyPath=\"opq\" />" +
+                          "<PropertyValue Property=\"NodeDrillStateProperty\" PropertyPath=\"x/y/z\" />" +
+                        "</Record>" +
+                      "</Annotation>" +
+                    "</EnumType>" +
+                  "</Schema>" +
+                "</edmx:DataServices>" +
+              "</edmx:Edmx>");
+
+            // Act & Assert for JSON
+            WriteAndVerifyJson(model, @"{
+  ""$Version"": ""4.0"",
+  ""Aggregation"": {
+    ""RecursiveHierarchyType"": {
+      ""$Kind"": ""ComplexType"",
+      ""NodeProperty"": {
+        ""$Type"": ""Edm.PropertyPath""
+      },
+      ""ParentNavigationProperty"": {
+        ""$Type"": ""Edm.NavigationPropertyPath""
+      }
+    },
+    ""RecursiveHierarchy"": {
+      ""$Kind"": ""Term"",
+      ""$Type"": ""Aggregation.RecursiveHierarchyType"",
+      ""$Nullable"": true
+    }
+  },
+  ""Common"": {
+    ""RecursiveHierarchyType"": {
+      ""$Kind"": ""ComplexType"",
+      ""ExternalNodeKeyProperty"": {
+        ""$Type"": ""Edm.PropertyPath""
+      },
+      ""NodeDrillStateProperty"": {
+        ""$Type"": ""Edm.PropertyPath""
+      }
+    },
+    ""RecursiveHierarchy"": {
+      ""$Kind"": ""Term"",
+      ""$Type"": ""Common.RecursiveHierarchyType"",
+      ""$BaseTerm"": ""Aggregation.RecursiveHierarchy"",
+      ""$Nullable"": true
+    }
+  },
+  ""NS"": {
+    ""Appliance"": {
+      ""$Kind"": ""EnumType"",
+      ""$UnderlyingType"": ""Edm.Int64"",
+      ""$IsFlags"": true,
+      ""@Common.RecursiveHierarchy"": {
+        ""NodeProperty"": ""a/b/c"",
+        ""ParentNavigationProperty"": ""e/f/g"",
+        ""ExternalNodeKeyProperty"": ""opq"",
+        ""NodeDrillStateProperty"": ""x/y/z""
+      }
+    }
+  }
+}");
+        }
+
         [Fact]
         public void CanWritePropertyWithCoreTypeDefinitionAndValidationPassed()
         {
diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/SchemaJsonParserTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/SchemaJsonParserTests.cs
index 137cb4572c..85ebe10c45 100644
--- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/SchemaJsonParserTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Parsing/SchemaJsonParserTests.cs
@@ -286,13 +286,15 @@ public void ParseCsdlTypeDefinitionWithMembersWorksAsExpected()
         #endregion
 
         #region Term
+
         [Fact]
-        public void ParseCsdlTermWithMembersWorksAsExpected()
+        public void ParseCsdlTermWithBaseTermAndMembersWorksAsExpected()
         {
             string json =  @"""ConformanceLevel"": {
   ""$Kind"": ""Term"",
   ""$Type"": ""Capabilities.ConformanceLevelType"",
   ""$Nullable"": true,
+  ""$BaseTerm"": ""NS.BaseTerm"",
   ""$AppliesTo"": [
     ""EntityContainer""
   ],
@@ -308,6 +310,8 @@ public void ParseCsdlTermWithMembersWorksAsExpected()
             Assert.Null(term.DefaultValue);
             Assert.True(term.HasVocabularyAnnotations);
 
+            Assert.Equal("NS.BaseTerm", term.BaseTermName);
+
             CsdlNamedTypeReference namedType = Assert.IsType<CsdlNamedTypeReference>(term.Type);
             Assert.Equal("Capabilities.ConformanceLevelType", namedType.FullName);
             Assert.True(namedType.IsNullable);
diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSerializationVisitorTests.cs b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSerializationVisitorTests.cs
index 2946095263..67650e2188 100644
--- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSerializationVisitorTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Csdl/Serialization/EdmModelCsdlSerializationVisitorTests.cs
@@ -815,6 +815,34 @@ public void VerifyTermWrittenCorrectly()
 }");
         }
 
+        [Fact]
+        public void VerifyTermWithBaseTermWrittenCorrectly()
+        {
+            // Arrange
+            IEdmPrimitiveTypeReference stringType = EdmCoreModel.Instance.GetString(true);
+            EdmTerm baseTerm = new EdmTerm("NS", "BaseTerm", stringType);
+            EdmTerm term = new EdmTerm("NS", "MyAnnotation", stringType, baseTerm, "Function,Action,EntitySet", null);
+
+            // Act & Assert for XML
+            VisitAndVerifyXml(v => v.VisitSchemaElement(term),
+                @"<Term Name=""MyAnnotation"" Type=""Edm.String"" BaseTerm=""NS.BaseTerm"" AppliesTo=""Function,Action,EntitySet"" />");
+
+            // Act & Assert for JSON
+            VisitAndVerifyJson(v => v.VisitSchemaElement(term), @"{
+  ""MyAnnotation"": {
+    ""$Kind"": ""Term"",
+    ""$Type"": ""Edm.String"",
+    ""$BaseTerm: ""NS.BaseTerm"",
+    ""$AppliesTo"": [
+      ""Function"",
+      ""Action"",
+      ""EntitySet""
+    ],
+    ""$Nullable"": true
+  }
+}");
+        }
+
         [Fact]
         public void VerifyTermWithAnnotationsWrittenCorrectly()
         {
diff --git a/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.net45.bsl b/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.net45.bsl
index c00427b1e7..179e99dc9d 100644
--- a/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.net45.bsl
+++ b/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.net45.bsl
@@ -3048,6 +3048,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     BadCyclicComplex = 227
     BadCyclicEntity = 229
     BadCyclicEntityContainer = 228
+    BadCyclicTerm = 401
     BadNavigationProperty = 74
     BadNonComputableAssociationEnd = 235
     BadPrincipalPropertiesInReferentialConstraint = 353
@@ -3135,7 +3136,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidBinary = 283
     InvalidBoolean = 27
     InvalidCastExpressionIncorrectNumberOfOperands = 303
-    InvalidCollectionValue = 403
+    InvalidCollectionValue = 404
     InvalidDate = 375
     InvalidDateTime = 285
     InvalidDateTimeOffset = 286
@@ -3151,9 +3152,9 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidIfExpressionIncorrectNumberOfOperands = 290
     InvalidInteger = 278
     InvalidIsTypeExpressionIncorrectNumberOfOperands = 293
-    InvalidJson = 404
+    InvalidJson = 405
     InvalidKey = 75
-    InvalidKeyValue = 401
+    InvalidKeyValue = 402
     InvalidLabeledElementExpressionIncorrectNumberOfOperands = 300
     InvalidLong = 277
     InvalidMaxLength = 276
@@ -3163,7 +3164,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidName = 17
     InvalidNamespaceName = 163
     InvalidNavigationPropertyType = 258
-    InvalidNumberType = 406
+    InvalidNumberType = 407
     InvalidOnDelete = 97
     InvalidOperationImportParameterMode = 333
     InvalidParameterMode = 280
@@ -3193,7 +3194,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     MetadataDocumentCannotHaveMoreThanOneEntityContainer = 365
     MismatchNumberOfPropertiesInRelationshipConstraint = 114
     MissingAttribute = 15
-    MissingRequiredProperty = 410
+    MissingRequiredProperty = 411
     MissingType = 18
     NameTooLong = 60
     NavigationMappingMustBeBidirectional = 344
@@ -3244,7 +3245,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     RequiredParametersMustPrecedeOptional = 379
     SameRoleReferredInReferentialConstraint = 119
     ScaleOutOfRange = 52
-    SchemaCannotHaveMoreThanOneEntityContainer = 402
+    SchemaCannotHaveMoreThanOneEntityContainer = 403
     SchemaElementMustNotHaveKindOfNone = 338
     SimilarRelationshipEnd = 153
     SingleFileExpected = 323
@@ -3261,18 +3262,18 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     TypeSemanticsCouldNotConvertTypeReference = 230
     UnboundFunctionOverloadHasIncorrectReturnType = 219
     UnderlyingTypeIsBadBecauseEnumTypeIsBad = 261
-    UnexpectedElement = 408
-    UnexpectedValueKind = 409
+    UnexpectedElement = 409
+    UnexpectedValueKind = 410
     UnexpectedXmlAttribute = 9
     UnexpectedXmlElement = 10
     UnexpectedXmlNodeType = 8
     UnknownEdmVersion = 325
     UnknownEdmxVersion = 324
-    UnknownElementValueKind = 405
+    UnknownElementValueKind = 406
     UnresolvedNavigationPropertyBindingPath = 378
     UnresolvedNavigationPropertyPartnerPath = 377
     UnresolvedReferenceUriInEdmxReference = 374
-    UnsupportedElement = 407
+    UnsupportedElement = 408
     UrlEscapeFunctionMustBeBoundFunction = 155
     UrlEscapeFunctionMustHaveOnlyOneEdmStringParameter = 156
     XmlError = 5
@@ -3687,6 +3688,7 @@ public interface Microsoft.OData.Edm.Vocabularies.IEdmStructuredValue : IEdmElem
 
 public interface Microsoft.OData.Edm.Vocabularies.IEdmTerm : IEdmElement, IEdmNamedElement, IEdmSchemaElement, IEdmVocabularyAnnotatable {
     string AppliesTo  { public abstract get; }
+    Microsoft.OData.Edm.Vocabularies.IEdmTerm BaseTerm  { public abstract get; }
     string DefaultValue  { public abstract get; }
     Microsoft.OData.Edm.IEdmTypeReference Type  { public abstract get; }
 }
@@ -4011,10 +4013,13 @@ public class Microsoft.OData.Edm.Vocabularies.EdmTerm : Microsoft.OData.Edm.EdmN
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.EdmPrimitiveTypeKind type)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.EdmPrimitiveTypeKind type, string appliesTo)
+    public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, Microsoft.OData.Edm.Vocabularies.IEdmTerm baseTerm)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, string appliesTo)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, string appliesTo, string defaultValue)
+    public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, Microsoft.OData.Edm.Vocabularies.IEdmTerm baseTerm, string appliesTo, string defaultValue)
 
     string AppliesTo  { public virtual get; }
+    Microsoft.OData.Edm.Vocabularies.IEdmTerm BaseTerm  { public virtual get; }
     string DefaultValue  { public virtual get; }
     string FullName  { public virtual get; }
     string Namespace  { public virtual get; }
@@ -4095,6 +4100,10 @@ public sealed class Microsoft.OData.Edm.Vocabularies.TryGetClrTypeName : System.
     public virtual bool Invoke (Microsoft.OData.Edm.IEdmModel edmModel, string edmTypeName, out System.String& clrTypeName)
 }
 
+public sealed class Microsoft.OData.Edm.Vocabularies.V1.AuthorizationVocabularyModel {
+    public static readonly Microsoft.OData.Edm.IEdmModel Instance = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsModel
+}
+
 public sealed class Microsoft.OData.Edm.Vocabularies.V1.CapabilitiesVocabularyConstants {
     public static string ChangeTracking = "Org.OData.Capabilities.V1.ChangeTracking"
     public static string ChangeTrackingExpandableProperties = "ExpandableProperties"
@@ -4145,6 +4154,7 @@ public sealed class Microsoft.OData.Edm.Vocabularies.V1.CoreVocabularyModel {
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm PermissionsTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm RequiresTypeTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm ResourcePathTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
+    public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm RevisionsTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
 }
 
 public sealed class Microsoft.OData.Edm.Vocabularies.V1.ValidationVocabularyModel {
@@ -4167,6 +4177,10 @@ public sealed class Microsoft.OData.Edm.Vocabularies.Community.V1.CommunityVocab
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm UrlEscapeFunctionTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
 }
 
+public sealed class Microsoft.OData.Edm.Vocabularies.Measures.V1.MeasuresVocabularyModel {
+    public static readonly Microsoft.OData.Edm.IEdmModel Instance = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsModel
+}
+
 >>>Microsoft.OData.Core
 public enum Microsoft.OData.BatchPayloadUriOption : int {
     AbsoluteUri = 0
@@ -7742,21 +7756,6 @@ public abstract class Microsoft.OData.Client.OperationResponse {
     int StatusCode  { public get; }
 }
 
-[
-ExtensionAttribute(),
-]
-public sealed class Microsoft.OData.Client.DataServiceExtensions {
-    [
-    ExtensionAttribute(),
-    ]
-    public static int CountDistinct (IEnumerable`1 source, Func`2 selector)
-
-    [
-    ExtensionAttribute(),
-    ]
-    public static int CountDistinct (IQueryable`1 source, Expression`1 selector)
-}
-
 public sealed class Microsoft.OData.Client.Utility {
     public static System.Collections.Generic.IEnumerable`1[[System.Object]] GetCustomAttributes (System.Type type, System.Type attributeType, bool inherit)
 }
diff --git a/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard1.1.bsl b/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard1.1.bsl
index 7de964dc6c..f92d49f170 100644
--- a/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard1.1.bsl
+++ b/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard1.1.bsl
@@ -3048,6 +3048,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     BadCyclicComplex = 227
     BadCyclicEntity = 229
     BadCyclicEntityContainer = 228
+    BadCyclicTerm = 401
     BadNavigationProperty = 74
     BadNonComputableAssociationEnd = 235
     BadPrincipalPropertiesInReferentialConstraint = 353
@@ -3135,7 +3136,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidBinary = 283
     InvalidBoolean = 27
     InvalidCastExpressionIncorrectNumberOfOperands = 303
-    InvalidCollectionValue = 403
+    InvalidCollectionValue = 404
     InvalidDate = 375
     InvalidDateTime = 285
     InvalidDateTimeOffset = 286
@@ -3151,9 +3152,9 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidIfExpressionIncorrectNumberOfOperands = 290
     InvalidInteger = 278
     InvalidIsTypeExpressionIncorrectNumberOfOperands = 293
-    InvalidJson = 404
+    InvalidJson = 405
     InvalidKey = 75
-    InvalidKeyValue = 401
+    InvalidKeyValue = 402
     InvalidLabeledElementExpressionIncorrectNumberOfOperands = 300
     InvalidLong = 277
     InvalidMaxLength = 276
@@ -3163,7 +3164,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidName = 17
     InvalidNamespaceName = 163
     InvalidNavigationPropertyType = 258
-    InvalidNumberType = 406
+    InvalidNumberType = 407
     InvalidOnDelete = 97
     InvalidOperationImportParameterMode = 333
     InvalidParameterMode = 280
@@ -3193,7 +3194,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     MetadataDocumentCannotHaveMoreThanOneEntityContainer = 365
     MismatchNumberOfPropertiesInRelationshipConstraint = 114
     MissingAttribute = 15
-    MissingRequiredProperty = 410
+    MissingRequiredProperty = 411
     MissingType = 18
     NameTooLong = 60
     NavigationMappingMustBeBidirectional = 344
@@ -3244,7 +3245,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     RequiredParametersMustPrecedeOptional = 379
     SameRoleReferredInReferentialConstraint = 119
     ScaleOutOfRange = 52
-    SchemaCannotHaveMoreThanOneEntityContainer = 402
+    SchemaCannotHaveMoreThanOneEntityContainer = 403
     SchemaElementMustNotHaveKindOfNone = 338
     SimilarRelationshipEnd = 153
     SingleFileExpected = 323
@@ -3261,18 +3262,18 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     TypeSemanticsCouldNotConvertTypeReference = 230
     UnboundFunctionOverloadHasIncorrectReturnType = 219
     UnderlyingTypeIsBadBecauseEnumTypeIsBad = 261
-    UnexpectedElement = 408
-    UnexpectedValueKind = 409
+    UnexpectedElement = 409
+    UnexpectedValueKind = 410
     UnexpectedXmlAttribute = 9
     UnexpectedXmlElement = 10
     UnexpectedXmlNodeType = 8
     UnknownEdmVersion = 325
     UnknownEdmxVersion = 324
-    UnknownElementValueKind = 405
+    UnknownElementValueKind = 406
     UnresolvedNavigationPropertyBindingPath = 378
     UnresolvedNavigationPropertyPartnerPath = 377
     UnresolvedReferenceUriInEdmxReference = 374
-    UnsupportedElement = 407
+    UnsupportedElement = 408
     UrlEscapeFunctionMustBeBoundFunction = 155
     UrlEscapeFunctionMustHaveOnlyOneEdmStringParameter = 156
     XmlError = 5
@@ -3687,6 +3688,7 @@ public interface Microsoft.OData.Edm.Vocabularies.IEdmStructuredValue : IEdmElem
 
 public interface Microsoft.OData.Edm.Vocabularies.IEdmTerm : IEdmElement, IEdmNamedElement, IEdmSchemaElement, IEdmVocabularyAnnotatable {
     string AppliesTo  { public abstract get; }
+    Microsoft.OData.Edm.Vocabularies.IEdmTerm BaseTerm  { public abstract get; }
     string DefaultValue  { public abstract get; }
     Microsoft.OData.Edm.IEdmTypeReference Type  { public abstract get; }
 }
@@ -4011,10 +4013,13 @@ public class Microsoft.OData.Edm.Vocabularies.EdmTerm : Microsoft.OData.Edm.EdmN
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.EdmPrimitiveTypeKind type)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.EdmPrimitiveTypeKind type, string appliesTo)
+    public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, Microsoft.OData.Edm.Vocabularies.IEdmTerm baseTerm)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, string appliesTo)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, string appliesTo, string defaultValue)
+    public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, Microsoft.OData.Edm.Vocabularies.IEdmTerm baseTerm, string appliesTo, string defaultValue)
 
     string AppliesTo  { public virtual get; }
+    Microsoft.OData.Edm.Vocabularies.IEdmTerm BaseTerm  { public virtual get; }
     string DefaultValue  { public virtual get; }
     string FullName  { public virtual get; }
     string Namespace  { public virtual get; }
@@ -4095,6 +4100,10 @@ public sealed class Microsoft.OData.Edm.Vocabularies.TryGetClrTypeName : System.
     public virtual bool Invoke (Microsoft.OData.Edm.IEdmModel edmModel, string edmTypeName, out System.String& clrTypeName)
 }
 
+public sealed class Microsoft.OData.Edm.Vocabularies.V1.AuthorizationVocabularyModel {
+    public static readonly Microsoft.OData.Edm.IEdmModel Instance = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsModel
+}
+
 public sealed class Microsoft.OData.Edm.Vocabularies.V1.CapabilitiesVocabularyConstants {
     public static string ChangeTracking = "Org.OData.Capabilities.V1.ChangeTracking"
     public static string ChangeTrackingExpandableProperties = "ExpandableProperties"
@@ -4145,6 +4154,7 @@ public sealed class Microsoft.OData.Edm.Vocabularies.V1.CoreVocabularyModel {
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm PermissionsTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm RequiresTypeTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm ResourcePathTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
+    public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm RevisionsTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
 }
 
 public sealed class Microsoft.OData.Edm.Vocabularies.V1.ValidationVocabularyModel {
@@ -4167,6 +4177,10 @@ public sealed class Microsoft.OData.Edm.Vocabularies.Community.V1.CommunityVocab
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm UrlEscapeFunctionTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
 }
 
+public sealed class Microsoft.OData.Edm.Vocabularies.Measures.V1.MeasuresVocabularyModel {
+    public static readonly Microsoft.OData.Edm.IEdmModel Instance = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsModel
+}
+
 >>>Microsoft.OData.Core
 public enum Microsoft.OData.BatchPayloadUriOption : int {
     AbsoluteUri = 0
diff --git a/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard2.0.bsl b/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard2.0.bsl
index 4076175249..03b2483e8c 100644
--- a/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard2.0.bsl
+++ b/test/PublicApiTests/BaseLine/Microsoft.OData.PublicApi.netstandard2.0.bsl
@@ -3080,6 +3080,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     BadCyclicComplex = 227
     BadCyclicEntity = 229
     BadCyclicEntityContainer = 228
+    BadCyclicTerm = 401
     BadNavigationProperty = 74
     BadNonComputableAssociationEnd = 235
     BadPrincipalPropertiesInReferentialConstraint = 353
@@ -3167,7 +3168,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidBinary = 283
     InvalidBoolean = 27
     InvalidCastExpressionIncorrectNumberOfOperands = 303
-    InvalidCollectionValue = 403
+    InvalidCollectionValue = 404
     InvalidDate = 375
     InvalidDateTime = 285
     InvalidDateTimeOffset = 286
@@ -3183,9 +3184,9 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidIfExpressionIncorrectNumberOfOperands = 290
     InvalidInteger = 278
     InvalidIsTypeExpressionIncorrectNumberOfOperands = 293
-    InvalidJson = 404
+    InvalidJson = 405
     InvalidKey = 75
-    InvalidKeyValue = 401
+    InvalidKeyValue = 402
     InvalidLabeledElementExpressionIncorrectNumberOfOperands = 300
     InvalidLong = 277
     InvalidMaxLength = 276
@@ -3195,7 +3196,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     InvalidName = 17
     InvalidNamespaceName = 163
     InvalidNavigationPropertyType = 258
-    InvalidNumberType = 406
+    InvalidNumberType = 407
     InvalidOnDelete = 97
     InvalidOperationImportParameterMode = 333
     InvalidParameterMode = 280
@@ -3225,7 +3226,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     MetadataDocumentCannotHaveMoreThanOneEntityContainer = 365
     MismatchNumberOfPropertiesInRelationshipConstraint = 114
     MissingAttribute = 15
-    MissingRequiredProperty = 410
+    MissingRequiredProperty = 411
     MissingType = 18
     NameTooLong = 60
     NavigationMappingMustBeBidirectional = 344
@@ -3276,7 +3277,7 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     RequiredParametersMustPrecedeOptional = 379
     SameRoleReferredInReferentialConstraint = 119
     ScaleOutOfRange = 52
-    SchemaCannotHaveMoreThanOneEntityContainer = 402
+    SchemaCannotHaveMoreThanOneEntityContainer = 403
     SchemaElementMustNotHaveKindOfNone = 338
     SimilarRelationshipEnd = 153
     SingleFileExpected = 323
@@ -3293,18 +3294,18 @@ public enum Microsoft.OData.Edm.Validation.EdmErrorCode : int {
     TypeSemanticsCouldNotConvertTypeReference = 230
     UnboundFunctionOverloadHasIncorrectReturnType = 219
     UnderlyingTypeIsBadBecauseEnumTypeIsBad = 261
-    UnexpectedElement = 408
-    UnexpectedValueKind = 409
+    UnexpectedElement = 409
+    UnexpectedValueKind = 410
     UnexpectedXmlAttribute = 9
     UnexpectedXmlElement = 10
     UnexpectedXmlNodeType = 8
     UnknownEdmVersion = 325
     UnknownEdmxVersion = 324
-    UnknownElementValueKind = 405
+    UnknownElementValueKind = 406
     UnresolvedNavigationPropertyBindingPath = 378
     UnresolvedNavigationPropertyPartnerPath = 377
     UnresolvedReferenceUriInEdmxReference = 374
-    UnsupportedElement = 407
+    UnsupportedElement = 408
     UrlEscapeFunctionMustBeBoundFunction = 155
     UrlEscapeFunctionMustHaveOnlyOneEdmStringParameter = 156
     XmlError = 5
@@ -3719,6 +3720,7 @@ public interface Microsoft.OData.Edm.Vocabularies.IEdmStructuredValue : IEdmElem
 
 public interface Microsoft.OData.Edm.Vocabularies.IEdmTerm : IEdmElement, IEdmNamedElement, IEdmSchemaElement, IEdmVocabularyAnnotatable {
     string AppliesTo  { public abstract get; }
+    Microsoft.OData.Edm.Vocabularies.IEdmTerm BaseTerm  { public abstract get; }
     string DefaultValue  { public abstract get; }
     Microsoft.OData.Edm.IEdmTypeReference Type  { public abstract get; }
 }
@@ -4043,10 +4045,13 @@ public class Microsoft.OData.Edm.Vocabularies.EdmTerm : Microsoft.OData.Edm.EdmN
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.EdmPrimitiveTypeKind type)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.EdmPrimitiveTypeKind type, string appliesTo)
+    public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, Microsoft.OData.Edm.Vocabularies.IEdmTerm baseTerm)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, string appliesTo)
     public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, string appliesTo, string defaultValue)
+    public EdmTerm (string namespaceName, string name, Microsoft.OData.Edm.IEdmTypeReference type, Microsoft.OData.Edm.Vocabularies.IEdmTerm baseTerm, string appliesTo, string defaultValue)
 
     string AppliesTo  { public virtual get; }
+    Microsoft.OData.Edm.Vocabularies.IEdmTerm BaseTerm  { public virtual get; }
     string DefaultValue  { public virtual get; }
     string FullName  { public virtual get; }
     string Namespace  { public virtual get; }
@@ -4127,6 +4132,10 @@ public sealed class Microsoft.OData.Edm.Vocabularies.TryGetClrTypeName : System.
     public virtual bool Invoke (Microsoft.OData.Edm.IEdmModel edmModel, string edmTypeName, out System.String& clrTypeName)
 }
 
+public sealed class Microsoft.OData.Edm.Vocabularies.V1.AuthorizationVocabularyModel {
+    public static readonly Microsoft.OData.Edm.IEdmModel Instance = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsModel
+}
+
 public sealed class Microsoft.OData.Edm.Vocabularies.V1.CapabilitiesVocabularyConstants {
     public static string ChangeTracking = "Org.OData.Capabilities.V1.ChangeTracking"
     public static string ChangeTrackingExpandableProperties = "ExpandableProperties"
@@ -4177,6 +4186,7 @@ public sealed class Microsoft.OData.Edm.Vocabularies.V1.CoreVocabularyModel {
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm PermissionsTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm RequiresTypeTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm ResourcePathTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
+    public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm RevisionsTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
 }
 
 public sealed class Microsoft.OData.Edm.Vocabularies.V1.ValidationVocabularyModel {
@@ -4199,6 +4209,10 @@ public sealed class Microsoft.OData.Edm.Vocabularies.Community.V1.CommunityVocab
     public static readonly Microsoft.OData.Edm.Vocabularies.IEdmTerm UrlEscapeFunctionTerm = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsTerm
 }
 
+public sealed class Microsoft.OData.Edm.Vocabularies.Measures.V1.MeasuresVocabularyModel {
+    public static readonly Microsoft.OData.Edm.IEdmModel Instance = Microsoft.OData.Edm.Csdl.CsdlSemantics.CsdlSemanticsModel
+}
+
 >>>Microsoft.OData.Core
 public enum Microsoft.OData.BatchPayloadUriOption : int {
     AbsoluteUri = 0
@@ -7774,21 +7788,6 @@ public abstract class Microsoft.OData.Client.OperationResponse {
     int StatusCode  { public get; }
 }
 
-[
-ExtensionAttribute(),
-]
-public sealed class Microsoft.OData.Client.DataServiceExtensions {
-    [
-    ExtensionAttribute(),
-    ]
-    public static int CountDistinct (IEnumerable`1 source, Func`2 selector)
-
-    [
-    ExtensionAttribute(),
-    ]
-    public static int CountDistinct (IQueryable`1 source, Expression`1 selector)
-}
-
 public sealed class Microsoft.OData.Client.Utility {
     public static System.Collections.Generic.IEnumerable`1[[System.Object]] GetCustomAttributes (System.Type type, System.Type attributeType, bool inherit)
 }