@@ -22,7 +22,7 @@ Npgsql 3.3 is out and available on nuget.org. This is a major release with subst
 
 * .NET Standard 1.3 is no longer supported. .NET Standard 2.0 is the lowest supported version.
 * Parameter types have become more strict. Previous versions allowed to you pass arbitrary value types, such as writing CLR string to int columns, or anything that implemented IConvertible. Although some implicit conversions are still supported (e.g. long -> int, short -> int), some have been removed.
-* `NpgsqlParameter.EnumType`, which was already obsolete, was removed. Use `NpgsqlParameter.SpecificType` instead.
+* `NpgsqlParameter.EnumType` and `NpgsqlParameter.SpecificType` have been removed. To send enums or composites, use the new `NpgsqlParameter.DataTypeName` instead. See [Composites and Enums](../types/enums_and_composites.md) for more details.
 * Parameter names are no longer trimmed, set your names to the exact parameter name specified in your SQL.
 * If a parameter's name isn't set, it will no longer default to Parameter1, Parameter2, etc.
 * The following APIs "connection capability" APIs have been removed from NpgsqlConnection: `UseConformantStrings`, `SupportsEStringPrefix`, `UseSslStream`.
 
@@ -403,37 +403,6 @@ public string DataTypeName
             }
         }
 
-        /// <summary>
-        /// Used in combination with NpgsqlDbType.Enum or NpgsqlDbType.Composite to indicate the specific enum or composite type.
-        /// For other NpgsqlDbTypes, this field is not used.
-        /// </summary>
-        [PublicAPI, CanBeNull, Obsolete("Use " + nameof(DataTypeName) + " instead.")]
-        public Type SpecificType
-        {
-            get => SpecificTypeInternal;
-            set => SpecificTypeInternal = value;
-        }
-
-        private protected Type SpecificTypeInternal
-        {
-            get {
-                if (_specificType != null)
-                    return _specificType;
-
-                // Try to infer type if NpgsqlDbType is Enum or has not been set
-                if ((!_npgsqlDbType.HasValue || _npgsqlDbType == NpgsqlDbType.Enum) && _value != null)
-                {
-                    var type = _value.GetType();
-                    if (type.GetTypeInfo().IsEnum)
-                        return type;
-                    if (type.IsArray && type.GetElementType().GetTypeInfo().IsEnum)
-                        return type.GetElementType();
-                }
-                return null;
-            }
-            set => _specificType = value;
-        }
-
         #endregion Type
 
         #region Other Properties
@@ -551,7 +520,7 @@ internal virtual void ResolveHandler(ConnectorTypeMapper typeMapper)
                 return;
 
             if (_npgsqlDbType.HasValue)
-                Handler = typeMapper.GetByNpgsqlDbType(_npgsqlDbType.Value, SpecificTypeInternal);
+                Handler = typeMapper.GetByNpgsqlDbType(_npgsqlDbType.Value);
             else if (_dataTypeName != null)
                 Handler = typeMapper.GetByDataTypeName(_dataTypeName);
             else if (_dbType.HasValue)
 
@@ -71,7 +71,7 @@ internal override void ResolveHandler(ConnectorTypeMapper typeMapper)
 
             // TODO: Better exceptions in case of cast failure etc.
             if (_npgsqlDbType.HasValue)
-                Handler = typeMapper.GetByNpgsqlDbType(_npgsqlDbType.Value, SpecificTypeInternal);
+                Handler = typeMapper.GetByNpgsqlDbType(_npgsqlDbType.Value);
             else if (_dataTypeName != null)
                 Handler = typeMapper.GetByDataTypeName(_dataTypeName);
             else if (_dbType.HasValue)
 
@@ -90,16 +90,6 @@ public enum NpgsqlDbType
 
         #endregion
 
-        #region Enumerated Types
-
-        /// <summary>
-        /// Corresponds to the PostgreSQL "enum" type.
-        /// </summary>
-        /// <remarks>See http://www.postgresql.org/docs/current/static/datatype-enum.html</remarks>
-        Enum = 47,
-
-        #endregion
-
         #region Geometric types
 
         /// <summary>
@@ -388,16 +378,6 @@ public enum NpgsqlDbType
 
         #endregion
 
-        #region Composite Types
-
-        /// <summary>
-        /// Corresponds to the PostgreSQL "composite" type.
-        /// </summary>
-        /// <remarks>See http://www.postgresql.org/docs/current/static/rowtypes.html</remarks>
-        Composite = 48,
-
-        #endregion
-
         #region Range Types
 
         /// <summary>
 
@@ -114,40 +114,12 @@ internal bool TryGetByOID(uint oid, out NpgsqlTypeHandler handler)
             return false;
         }
 
-        internal NpgsqlTypeHandler GetByNpgsqlDbType(NpgsqlDbType npgsqlDbType, Type specificType = null)
-        {
-            if (specificType != null && (npgsqlDbType & NpgsqlDbType.Enum) == 0 && (npgsqlDbType & NpgsqlDbType.Composite) == 0)
-                throw new ArgumentException($"{nameof(specificType)} can only be used with {nameof(NpgsqlDbType.Enum)} or {nameof(NpgsqlDbType.Composite)}");
-
-            if (_byNpgsqlDbType.TryGetValue(npgsqlDbType, out var handler))
-                return handler;
+        internal NpgsqlTypeHandler GetByNpgsqlDbType(NpgsqlDbType npgsqlDbType)
+            => _byNpgsqlDbType.TryGetValue(npgsqlDbType, out var handler)
+                ? handler
+                : throw new NpgsqlException($"The NpgsqlDbType '{npgsqlDbType}' isn't present in your database. " +
+                                             "You may need to install an extension or upgrade to a newer version.");
 
-            if (specificType != null)  // Enum/composite
-            {
-                if ((npgsqlDbType & NpgsqlDbType.Array) == 0)
-                {
-                    if (_byClrType.TryGetValue(specificType, out handler))
-                        return handler;
-                }
-                else
-                {
-                    // Array of enum/composite
-                    if (_arrayHandlerByClrType.TryGetValue(specificType, out handler))
-                        return handler;
-                }
-                throw new InvalidOperationException($"The CLR type {specificType.Name} must be mapped with Npgsql before usage, please refer to the documentation.");
-            }
-
-            // Couldn't find already activated type, attempt to activate
-
-#pragma warning disable CS0618 // Type or member is obsolete
-            if (npgsqlDbType == NpgsqlDbType.Enum || npgsqlDbType == NpgsqlDbType.Composite)
-                throw new InvalidCastException($"When specifying NpgsqlDbType.{nameof(NpgsqlDbType.Enum)}, {nameof(NpgsqlParameter.SpecificType)} must be specified as well");
-#pragma warning restore CS0618 // Type or member is obsolete
-
-            throw new NpgsqlException($"The NpgsqlDbType '{npgsqlDbType}' isn't present in your database. " +
-                                        "You may need to install an extension or upgrade to a newer version.");
-        }
 
         internal NpgsqlTypeHandler GetByDbType(DbType dbType)
         {
 
@@ -184,9 +184,6 @@ NpgsqlDbType ToNpgsqlDbType(Type type)
             if (ilist != null)
                 return NpgsqlDbType.Array | ToNpgsqlDbType(ilist.GetGenericArguments()[0]);
 
-            if (typeInfo.IsEnum)
-                return NpgsqlDbType.Enum;
-
             if (typeInfo.IsGenericType && type.GetGenericTypeDefinition() == typeof(NpgsqlRange<>))
                 return NpgsqlDbType.Range | ToNpgsqlDbType(type.GetGenericArguments()[0]);
 
 
@@ -78,10 +78,15 @@ public void CompositeTypeResolutionWithGlobalMapping()
                 {
                     conn.ReloadTypes();
 
-                    // Resolve type by NpgsqlDbType
+                    // Resolve type by DataTypeName
                     using (var cmd = new NpgsqlCommand("SELECT @p", conn))
                     {
-                        cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Composite) { SpecificType = typeof(SomeComposite), Value = DBNull.Value });
+                        cmd.Parameters.Add(new NpgsqlParameter
+                        {
+                            ParameterName = "p",
+                            DataTypeName = "composite1",
+                            Value = DBNull.Value
+                        });
                         using (var reader = cmd.ExecuteReader())
                         {
                             reader.Read();
@@ -135,7 +140,13 @@ public void CompositeTypeResolutionWithLateMapping()
                 conn.TypeMapper.MapComposite<SomeComposite>("composite2");
                 using (var cmd = new NpgsqlCommand("SELECT @p", conn))
                 {
-                    cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Composite) { SpecificType = typeof(SomeComposite), Value = DBNull.Value });
+                    cmd.Parameters.Add(new NpgsqlParameter
+                    {
+                        ParameterName = "p",
+                        DataTypeName = "composite2",
+                        Value = DBNull.Value
+                    });
+
                     using (var reader = cmd.ExecuteReader())
                     {
                         reader.Read();
@@ -181,9 +192,11 @@ public void LateMapping()
                 var expected = new SomeComposite {x = 8, SomeText = "foo"};
                 using (var cmd = new NpgsqlCommand("SELECT @p1::composite3, @p2::composite3", conn))
                 {
-                    cmd.Parameters.Add(new NpgsqlParameter("p1", NpgsqlDbType.Composite) {
-                        Value = expected,
-                        SpecificType = typeof(SomeComposite)
+                    cmd.Parameters.Add(new NpgsqlParameter
+                    {
+                        ParameterName = "p1",
+                        DataTypeName = "composite3",
+                        Value = expected
                     });
                     cmd.Parameters.AddWithValue("p2", expected);
                     using (var reader = cmd.ExecuteReader())
@@ -317,9 +330,11 @@ public void Array()
 
                 using (var cmd = new NpgsqlCommand("SELECT @p1::composite5[], @p2::composite5[]", conn))
                 {
-                    cmd.Parameters.Add(new NpgsqlParameter("p1", NpgsqlDbType.Array | NpgsqlDbType.Composite) {
-                        Value = expected,
-                        SpecificType = typeof(SomeComposite)
+                    cmd.Parameters.Add(new NpgsqlParameter
+                    {
+                        ParameterName = "p1",
+                        DataTypeName = "_composite5",
+                        Value = expected
                     });
                     cmd.Parameters.AddWithValue("p2", expected); // Infer
                     using (var reader = cmd.ExecuteReader())
 
@@ -55,10 +55,15 @@ public void EnumTypeResolutionWithGlobalMapping()
                 {
                     conn.ReloadTypes();
 
-                    // Resolve type by NpgsqlDbType
+                    // Resolve type by DataTypeName
                     using (var cmd = new NpgsqlCommand("SELECT @p", conn))
                     {
-                        cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Enum) { SpecificType = typeof(Mood), Value=DBNull.Value });
+                        cmd.Parameters.Add(new NpgsqlParameter
+                        {
+                            ParameterName = "p",
+                            DataTypeName = "mood1",
+                            Value = DBNull.Value
+                        });
                         using (var reader = cmd.ExecuteReader())
                         {
                             reader.Read();
@@ -113,7 +118,12 @@ public void EnumTypeResolutionWithLateMapping()
                 conn.TypeMapper.MapEnum<Mood>("mood2");
                 using (var cmd = new NpgsqlCommand("SELECT @p", conn))
                 {
-                    cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Enum) { SpecificType = typeof(Mood), Value = DBNull.Value });
+                    cmd.Parameters.Add(new NpgsqlParameter
+                    {
+                        ParameterName = "p",
+                        DataTypeName = "mood2",
+                        Value = DBNull.Value
+                    });
                     using (var reader = cmd.ExecuteReader())
                     {
                         reader.Read();
@@ -157,8 +167,13 @@ public void LateMapping()
                 conn.TypeMapper.MapEnum<Mood>("mood3");
                 const Mood expected = Mood.Ok;
                 var cmd = new NpgsqlCommand("SELECT @p1::MOOD3, @p2::MOOD3", conn);
-                var p1 = new NpgsqlParameter("p1", NpgsqlDbType.Enum) {SpecificType = typeof(Mood), Value = expected};
-                var p2 = new NpgsqlParameter {ParameterName = "p2", Value = expected};
+                var p1 = new NpgsqlParameter
+                {
+                    ParameterName = "p1",
+                    DataTypeName = "mood3",
+                    Value = expected
+                };
+                var p2 = new NpgsqlParameter { ParameterName = "p2", Value = expected };
                 cmd.Parameters.Add(p1);
                 cmd.Parameters.Add(p2);
                 var reader = cmd.ExecuteReader();
@@ -185,8 +200,10 @@ public void DualEnums()
                 conn.TypeMapper.MapEnum<TestEnum>("test_enum");
                 var cmd = new NpgsqlCommand("SELECT @p1", conn);
                 var expected = new[] { Mood.Ok, Mood.Sad };
-                var p = new NpgsqlParameter("p1", NpgsqlDbType.Enum | NpgsqlDbType.Array) {
-                    SpecificType = typeof(Mood),
+                var p = new NpgsqlParameter
+                {
+                    ParameterName = "p1",
+                    DataTypeName = "_mood4",
                     Value = expected
                 };
                 cmd.Parameters.Add(p);
@@ -249,8 +266,10 @@ public void Array()
                 var expected = new[] {Mood.Ok, Mood.Happy};
                 using (var cmd = new NpgsqlCommand("SELECT @p1::MOOD6[], @p2::MOOD6[]", conn))
                 {
-                    var p1 = new NpgsqlParameter("p1", NpgsqlDbType.Enum | NpgsqlDbType.Array) {
-                        SpecificType = typeof(Mood),
+                    var p1 = new NpgsqlParameter
+                    {
+                        ParameterName = "p1",
+                        DataTypeName = "_mood6",
                         Value = expected
                     };
                     var p2 = new NpgsqlParameter {ParameterName = "p2", Value = expected};
@@ -510,46 +529,6 @@ public void GlobalMappingsAndPooling()
             }
         }
 
-        [Test]
-        public void TestEnumType()
-        {
-            using (var conn = OpenConnection())
-            {
-                conn.ExecuteNonQuery("CREATE TYPE pg_temp.test_enum2 AS ENUM ('label1', 'label2', 'label3')");
-                conn.ReloadTypes();
-                conn.TypeMapper.MapEnum<TestEnum>("test_enum2");
-                using (var cmd = conn.CreateCommand())
-                {
-                    cmd.CommandText = "Select :p1, :p2, :p3, :p4, :p5";
-
-                    cmd.Parameters.AddWithValue("p1", TestEnum.label1);
-                    cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p2", NpgsqlDbType = NpgsqlDbType.Enum, SpecificType = typeof(TestEnum), Value = TestEnum.label2 });
-                    cmd.Parameters.AddWithValue("p3", new[] { TestEnum.label1, TestEnum.Label3 });
-                    cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p4", NpgsqlDbType = NpgsqlDbType.Array | NpgsqlDbType.Enum, SpecificType = typeof(TestEnum), Value = new[] { TestEnum.label1, TestEnum.Label3 } });
-                    cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p5", NpgsqlDbType = NpgsqlDbType.Enum, SpecificType = typeof(TestEnum), Value = DBNull.Value });
-
-                    Assert.AreEqual(NpgsqlDbType.Enum, cmd.Parameters[0].NpgsqlDbType);
-                    Assert.AreEqual(typeof(TestEnum), cmd.Parameters[0].SpecificType);
-                    Assert.AreEqual(NpgsqlDbType.Array | NpgsqlDbType.Enum, cmd.Parameters[2].NpgsqlDbType);
-                    Assert.AreEqual(typeof(TestEnum), cmd.Parameters[2].SpecificType);
-
-                    using (var rdr = cmd.ExecuteReader())
-                    {
-                        rdr.Read();
-                        Assert.AreEqual(typeof(TestEnum), rdr.GetValue(0).GetType());
-                        Assert.AreEqual(TestEnum.label1, rdr.GetValue(0));
-                        Assert.AreEqual(typeof(TestEnum), rdr.GetValue(1).GetType());
-                        Assert.AreEqual(TestEnum.label2, rdr.GetValue(1));
-                        Assert.AreEqual(typeof(TestEnum[]), rdr.GetValue(2).GetType());
-                        Assert.IsTrue(new[] { TestEnum.label1, TestEnum.Label3 }.SequenceEqual((TestEnum[])rdr.GetValue(2)));
-                        Assert.AreEqual(typeof(TestEnum[]), rdr.GetValue(3).GetType());
-                        Assert.IsTrue(new[] { TestEnum.label1, TestEnum.Label3 }.SequenceEqual((TestEnum[])rdr.GetValue(3)));
-                        Assert.AreEqual(typeof(TestEnum), rdr.GetFieldType(4));
-                    }
-                }
-            }
-        }
-
         enum TestEnum
         {
             label1,