diff --git a/src/Mapster.Async/TypeAdapterExtensions.cs b/src/Mapster.Async/TypeAdapterExtensions.cs
index 5ace867c..b42a754e 100644
--- a/src/Mapster.Async/TypeAdapterExtensions.cs
+++ b/src/Mapster.Async/TypeAdapterExtensions.cs
@@ -13,7 +13,16 @@ internal static U GetValueOrDefault<T, U>(this IDictionary<T, U> dict, T key)
             return dict.TryGetValue(key, out var value) ? value : default;
         }
 
-        public static TypeAdapterSetter<TDestination> AfterMappingAsync<TDestination>(
+
+		/// <summary>
+		/// Setup async operation
+		/// </summary>
+		/// <typeparam name="TDestination"></typeparam>
+		/// <param name="setter"></param>
+		/// <param name="action"></param>
+		/// <returns></returns>
+		/// <exception cref="InvalidOperationException"></exception>
+		public static TypeAdapterSetter<TDestination> AfterMappingAsync<TDestination>(
             this TypeAdapterSetter<TDestination> setter, Func<TDestination, Task> action)
         {
             setter.AfterMapping(dest =>
@@ -27,7 +36,17 @@ public static TypeAdapterSetter<TDestination> AfterMappingAsync<TDestination>(
             return setter;
         }
 
-        public static TypeAdapterSetter<TSource, TDestination> AfterMappingAsync<TSource, TDestination>(
+
+		/// <summary>
+		/// Setup async operation
+		/// </summary>
+		/// <typeparam name="TSource"></typeparam>
+		/// <typeparam name="TDestination"></typeparam>
+		/// <param name="setter"></param>
+		/// <param name="action"></param>
+		/// <returns></returns>
+		/// <exception cref="InvalidOperationException"></exception>
+		public static TypeAdapterSetter<TSource, TDestination> AfterMappingAsync<TSource, TDestination>(
             this TypeAdapterSetter<TSource, TDestination> setter, Func<TSource, TDestination, Task> action)
         {
             setter.AfterMapping((src, dest) =>
@@ -41,7 +60,14 @@ public static TypeAdapterSetter<TSource, TDestination> AfterMappingAsync<TSource
             return setter;
         }
 
-        public static async Task<TDestination> AdaptToTypeAsync<TDestination>(this IAdapterBuilder builder)
+
+		/// <summary>
+		/// Map asynchronously to destination type.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="builder"></param>
+		/// <returns>Type of destination object that mapped.</returns>
+		public static async Task<TDestination> AdaptToTypeAsync<TDestination>(this IAdapterBuilder builder)
         {
             var tasks = new List<Task>();
             builder.Parameters[ASYNC_KEY] = tasks;
@@ -54,7 +80,15 @@ public static async Task<TDestination> AdaptToTypeAsync<TDestination>(this IAdap
             }
         }
 
-        public static async Task<TDestination> AdaptToAsync<TDestination>(this IAdapterBuilder builder, TDestination destination)
+
+		/// <summary>
+		/// Map asynchronously to destination type.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="builder"></param>
+		/// <param name="destination">Destination object to map.</param>
+		/// <returns>Type of destination object that mapped.</returns>
+		public static async Task<TDestination> AdaptToAsync<TDestination>(this IAdapterBuilder builder, TDestination destination)
         {
             var tasks = new List<Task>();
             builder.Parameters[ASYNC_KEY] = tasks;
diff --git a/src/Mapster.Core/Register/AdaptAttributeBuilder.cs b/src/Mapster.Core/Register/AdaptAttributeBuilder.cs
index 93a85de1..6797700c 100644
--- a/src/Mapster.Core/Register/AdaptAttributeBuilder.cs
+++ b/src/Mapster.Core/Register/AdaptAttributeBuilder.cs
@@ -16,7 +16,12 @@ public AdaptAttributeBuilder(BaseAdaptAttribute attribute)
             this.Attribute = attribute;
         }
 
-        public AdaptAttributeBuilder ForTypes(params Type[] types)
+		/// <summary>
+		/// Configures the builder for specific types.	
+		/// </summary>
+		/// <param name="types">Types to configure.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder ForTypes(params Type[] types)
         {
             foreach (var type in types)
             {
@@ -27,7 +32,14 @@ public AdaptAttributeBuilder ForTypes(params Type[] types)
             return this;
         }
 
-        public AdaptAttributeBuilder ForAllTypesInNamespace(Assembly assembly, string @namespace)
+
+		/// <summary>
+		/// Configures the builder for all types in a given namespace within an assembly.
+		/// </summary>
+		/// <param name="assembly">The assembly containing the types.</param>
+		/// <param name="namespace">The namespace of the types to include.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder ForAllTypesInNamespace(Assembly assembly, string @namespace)
         {
             foreach (var type in assembly.GetTypes())
             {
@@ -40,7 +52,14 @@ public AdaptAttributeBuilder ForAllTypesInNamespace(Assembly assembly, string @n
             return this;
         }
 
-        public AdaptAttributeBuilder ForType<T>(Action<PropertySettingBuilder<T>>? propertyConfig = null)
+
+		/// <summary>
+		/// Configures the builder for a specific type and allows for property-specific configuration.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="propertyConfig">An optional action for configuring properties of the specified type.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder ForType<T>(Action<PropertySettingBuilder<T>>? propertyConfig = null)
         {
             if (!this.TypeSettings.TryGetValue(typeof(T), out var settings))
             {
@@ -52,7 +71,13 @@ public AdaptAttributeBuilder ForType<T>(Action<PropertySettingBuilder<T>>? prope
             return this;
         }
 
-        public AdaptAttributeBuilder ExcludeTypes(params Type[] types)
+
+		/// <summary>
+		/// Excludes specific types from the configuration.
+		/// </summary>
+		/// <param name="types">An array of types to exclude.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder ExcludeTypes(params Type[] types)
         {
             foreach (var type in types)
             {
@@ -62,7 +87,13 @@ public AdaptAttributeBuilder ExcludeTypes(params Type[] types)
             return this;
         }
 
-        public AdaptAttributeBuilder ExcludeTypes(Func<Type, bool> predicate)
+
+		/// <summary>
+		/// Exclude certain types from the adaptation process based on a provided predicate.
+		/// </summary>
+		/// <param name="predicate">Predicate function should evaluate to true for types that you want to exclude from the mapping and false for types that should not be excluded.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder ExcludeTypes(Func<Type, bool> predicate)
         {
             foreach (var type in this.TypeSettings.Keys.ToList())
             {
@@ -73,67 +104,135 @@ public AdaptAttributeBuilder ExcludeTypes(Func<Type, bool> predicate)
             return this;
         }
 
-        public AdaptAttributeBuilder IgnoreAttributes(params Type[] attributes)
+
+		/// <summary>
+		/// Specifies attributes to ignore during mapping.
+		/// </summary>
+		/// <param name="attributes">An array of attributes to ignore.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder IgnoreAttributes(params Type[] attributes)
         {
             this.Attribute.IgnoreAttributes = attributes;
             return this;
         }
 
-        public AdaptAttributeBuilder IgnoreNoAttributes(params Type[] attributes)
+
+		/// <summary>
+		/// Specifies attributes that should not be ignored during mapping.
+		/// </summary>
+		/// <param name="attributes">An array of attributes that should not be ignored.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder IgnoreNoAttributes(params Type[] attributes)
         {
             this.Attribute.IgnoreNoAttributes = attributes;
             return this;
         }
 
-        public AdaptAttributeBuilder IgnoreNamespaces(params string[] namespaces)
+
+		/// <summary>
+		/// Specifies namespaces to ignore during mapping.
+		/// </summary>
+		/// <param name="namespaces">An array of namespaces to ignore.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder IgnoreNamespaces(params string[] namespaces)
         {
             this.Attribute.IgnoreNamespaces = namespaces;
             return this;
         }
 
-        public AdaptAttributeBuilder IgnoreNullValues(bool value)
+
+		/// <summary>
+		/// Configures whether null values should be ignored during mapping.
+		/// </summary>
+		/// <param name="value">A boolean value indicating whether to ignore null values.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder IgnoreNullValues(bool value)
         {
             this.Attribute.IgnoreNullValues = value;
             return this;
         }
 
-        public AdaptAttributeBuilder RequireDestinationMemberSource(bool value)
+
+		/// <summary>
+		/// Configures whether a destination member source is required during.
+		/// </summary>
+		/// <param name="value">A boolean value indicating whether a destination member source is required.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder RequireDestinationMemberSource(bool value)
         {
             this.Attribute.RequireDestinationMemberSource = value;
             return this;
         }
 
-        public AdaptAttributeBuilder MapToConstructor(bool value)
+
+		/// <summary>
+		/// Configures whether mapping should be performed to constructors.
+		/// </summary>
+		/// <param name="value">A boolean value indicating whether mapping to constructors is enabled.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder MapToConstructor(bool value)
         {
             this.Attribute.MapToConstructor = value;
             return this;
         }
 
-        public AdaptAttributeBuilder MaxDepth(int depth)
+
+		/// <summary>
+		/// Sets the maximum depth for mapping.
+		/// </summary>
+		/// <param name="depth">The maximum depth for mapping.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder MaxDepth(int depth)
         {
             this.Attribute.MaxDepth = depth;
             return this;
         }
-        
-        public AdaptAttributeBuilder PreserveReference(bool value)
+
+
+		/// <summary>
+		/// Configures whether to preserve object references during mapping.
+		/// </summary>
+		/// <param name="value">A boolean value indicating whether to preserve object references.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder PreserveReference(bool value)
         {
             this.Attribute.PreserveReference = value;
             return this;
         }
-        
-        public AdaptAttributeBuilder ShallowCopyForSameType(bool value)
+
+
+		/// <summary>
+		/// Configures whether to perform a shallow copy for the same source and destination type.
+		/// </summary>
+		/// <param name="value">A boolean value indicating whether to perform a shallow copy.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder ShallowCopyForSameType(bool value)
         {
             this.Attribute.ShallowCopyForSameType = value;
             return this;
         }
 
-        public AdaptAttributeBuilder AlterType<TFrom, TTo>()
+
+		/// <summary>
+		/// Forward property types.
+		/// </summary>
+		/// <typeparam name="TFrom">Forward property from type.</typeparam>
+		/// <typeparam name="TTo">Forward property to type.</typeparam>
+		/// <returns></returns>
+		public AdaptAttributeBuilder AlterType<TFrom, TTo>()
         {
             this.AlterTypes.Add(type => type == typeof(TFrom) ? typeof(TTo) : null);
             return this;
         }
 
-        public AdaptAttributeBuilder AlterType(Func<Type, bool> predicate, Type toType)
+
+		/// <summary>
+		/// Forward property types for Code generation.
+		/// </summary>
+		/// <param name="predicate">A function that takes a Type as input and returns a Boolean value. This function is used to evaluate whether the forward property should be applied to the target type. If the predicate returns true, the target type will be replaced; otherwise, it remains unchanged.</param>
+		/// <param name="toType">Type of destination to forward property type.</param>
+		/// <returns></returns>
+		public AdaptAttributeBuilder AlterType(Func<Type, bool> predicate, Type toType)
         {
             this.AlterTypes.Add(type => predicate(type) ? toType : null);
             return this;
diff --git a/src/Mapster.Core/Register/PropertySettingBuilder.cs b/src/Mapster.Core/Register/PropertySettingBuilder.cs
index 03d10634..69b35b1c 100644
--- a/src/Mapster.Core/Register/PropertySettingBuilder.cs
+++ b/src/Mapster.Core/Register/PropertySettingBuilder.cs
@@ -23,21 +23,45 @@ private PropertySetting ForProperty(string name)
             return setting;
         }
 
-        public PropertySettingBuilder<T> Ignore<TReturn>(Expression<Func<T, TReturn>> member)
+
+		/// <summary>
+		/// Ignore a specific property during mapping.
+		/// </summary>
+		/// <typeparam name="TReturn"></typeparam>
+		/// <param name="member">A lambda expression that identifies the property to be ignored during mapping.</param>
+		/// <returns></returns>
+		public PropertySettingBuilder<T> Ignore<TReturn>(Expression<Func<T, TReturn>> member)
         {
             var setting = ForProperty(member.GetMemberName());
             setting.Ignore = true;
             return this;
         }
 
-        public PropertySettingBuilder<T> Map<TReturn>(Expression<Func<T, TReturn>> member, string targetPropertyName)
+
+		/// <summary>
+		/// Map a specific property of the source type to a target property with a different name during mapping.
+		/// </summary>
+		/// <typeparam name="TReturn"></typeparam>
+		/// <param name="member">A lambda expression that identifies the source property to be mapped.</param>
+		/// <param name="targetPropertyName">The name of the target property to which the source property should be mapped during the mapping process.</param>
+		/// <returns></returns>
+		public PropertySettingBuilder<T> Map<TReturn>(Expression<Func<T, TReturn>> member, string targetPropertyName)
         {
             var setting = ForProperty(member.GetMemberName());
             setting.TargetPropertyName = targetPropertyName;
             return this;
         }
 
-        public PropertySettingBuilder<T> Map<TReturn>(Expression<Func<T, TReturn>> member, Type targetPropertyType, string? targetPropertyName = null)
+
+		/// <summary>
+		/// Map a specific property of the source type to a target property with a different type and name during mapping.
+		/// </summary>
+		/// <typeparam name="TReturn"></typeparam>
+		/// <param name="member">A lambda expression that identifies the source property to be mapped.</param>
+		/// <param name="targetPropertyType">The type of the target property to which the source property should be mapped during the mapping process.</param>
+		/// <param name="targetPropertyName">The name of the target property to which the source property should be mapped.</param>
+		/// <returns></returns>
+		public PropertySettingBuilder<T> Map<TReturn>(Expression<Func<T, TReturn>> member, Type targetPropertyType, string? targetPropertyName = null)
         {
             var setting = ForProperty(member.GetMemberName());
             setting.TargetPropertyType = targetPropertyType;
@@ -45,7 +69,17 @@ public PropertySettingBuilder<T> Map<TReturn>(Expression<Func<T, TReturn>> membe
             return this;
         }
 
-        public PropertySettingBuilder<T> Map<TReturn, TReturn2>(Expression<Func<T, TReturn>> member, Expression<Func<T, TReturn2>> mapFunc, string? targetPropertyName = null)
+
+		/// <summary>
+		/// Map a specific property of the source type to a target property using a custom mapping function.
+		/// </summary>
+		/// <typeparam name="TReturn">Type of source property.</typeparam>
+		/// <typeparam name="TReturn2">Type of target property type.</typeparam>
+		/// <param name="member">A lambda expression that identifies the source property to be mapped.</param>
+		/// <param name="mapFunc">A lambda expression that defines the custom mapping function.</param>
+		/// <param name="targetPropertyName">The name of the target property to which the source property should be mapped.</param>
+		/// <returns></returns>
+		public PropertySettingBuilder<T> Map<TReturn, TReturn2>(Expression<Func<T, TReturn>> member, Expression<Func<T, TReturn2>> mapFunc, string? targetPropertyName = null)
         {
             var setting = ForProperty(member.GetMemberName());
             setting.MapFunc = mapFunc;
diff --git a/src/Mapster.DependencyInjection/ServiceMapper.cs b/src/Mapster.DependencyInjection/ServiceMapper.cs
index 03c8fc3d..1d909893 100644
--- a/src/Mapster.DependencyInjection/ServiceMapper.cs
+++ b/src/Mapster.DependencyInjection/ServiceMapper.cs
@@ -13,41 +13,88 @@ public ServiceMapper(IServiceProvider serviceProvider, TypeAdapterConfig config)
             _serviceProvider = serviceProvider;
         }
 
-        public override ITypeAdapterBuilder<TSource> From<TSource>(TSource source)
+		/// <summary>
+		/// Create mapping builder.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to create mapping builder.</typeparam>
+		/// <param name="source">Source object to create mapping builder.</param>
+		/// <returns></returns>
+		public override ITypeAdapterBuilder<TSource> From<TSource>(TSource source)
         {
             return base.From(source)
                 .AddParameters(DI_KEY, _serviceProvider);
         }
 
-        public override TDestination Map<TDestination>(object source)
+
+		/// <summary>
+		/// Perform mapping from source object to type of destination.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to create mapping builder.</typeparam>
+		/// <param name="source">Source object to create mapping builder.</param>
+		/// <returns>Type of destination object that mapped.</returns>
+		public override TDestination Map<TDestination>(object source)
         {
             using var scope = new MapContextScope();
             scope.Context.Parameters[DI_KEY] = _serviceProvider;
             return base.Map<TDestination>(source);
         }
 
-        public override TDestination Map<TSource, TDestination>(TSource source)
+
+		/// <summary>
+		/// Perform mapping from type of source to type of destination.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to map.</typeparam>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="source">Source object to map.</param>
+		/// <returns>Type of destination object that mapped.</returns>
+		public override TDestination Map<TSource, TDestination>(TSource source)
         {
             using var scope = new MapContextScope();
             scope.Context.Parameters[DI_KEY] = _serviceProvider;
             return base.Map<TSource, TDestination>(source);
         }
 
-        public override TDestination Map<TSource, TDestination>(TSource source, TDestination destination)
+
+		/// <summary>
+		/// Perform mapping from type of source to type of destination.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to map.</typeparam>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="destination">Destination object to map.</param>
+		/// <returns>Type of destination object that mapped.</returns>
+		public override TDestination Map<TSource, TDestination>(TSource source, TDestination destination)
         {
             using var scope = new MapContextScope();
             scope.Context.Parameters[DI_KEY] = _serviceProvider;
             return base.Map(source, destination);
         }
 
-        public override object Map(object source, Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Perform mapping source object from source type to destination type.
+		/// </summary>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="sourceType">Source type to map.</param>
+		/// <param name="destinationType">Destination type to map.</param>
+		/// <returns>Mapped object.</returns>
+		public override object Map(object source, Type sourceType, Type destinationType)
         {
             using var scope = new MapContextScope();
             scope.Context.Parameters[DI_KEY] = _serviceProvider;
             return base.Map(source, sourceType, destinationType);
         }
 
-        public override object Map(object source, object destination, Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Perform mapping source object from source type to destination type.
+		/// </summary>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="destination">Destination object to map.</param>
+		/// <param name="sourceType">Source type to map.</param>
+		/// <param name="destinationType">Destination type to map.</param>
+		/// <returns></returns>
+		public override object Map(object source, object destination, Type sourceType, Type destinationType)
         {
             using var scope = new MapContextScope();
             scope.Context.Parameters[DI_KEY] = _serviceProvider;
diff --git a/src/Mapster.EFCore/TypeAdapterBuilderExtensions.cs b/src/Mapster.EFCore/TypeAdapterBuilderExtensions.cs
index 11fa744d..3ab0cb5b 100644
--- a/src/Mapster.EFCore/TypeAdapterBuilderExtensions.cs
+++ b/src/Mapster.EFCore/TypeAdapterBuilderExtensions.cs
@@ -80,7 +80,14 @@ public static ITypeAdapterBuilder<TSource> EntityFromContext<TSource>(this IType
                 }, context.GetType().FullName);
         }
 
-        public static IQueryable<TDestination> ProjectToType<TDestination>(this IAdapterBuilder<IQueryable> source)
+
+		/// <summary>
+		/// Mapping from queryable.
+		/// </summary>
+		/// <typeparam name="TDestination">Type of destination.</typeparam>
+		/// <param name="source">Source object to adopt.</param>
+		/// <returns></returns>
+		public static IQueryable<TDestination> ProjectToType<TDestination>(this IAdapterBuilder<IQueryable> source)
         {
             var queryable = source.Source.ProjectToType<TDestination>(source.Config);
             if (!source.HasParameter || source.Parameters.All(it => it.Key.StartsWith("Mapster.")))
diff --git a/src/Mapster/Interfaces/IMapper.cs b/src/Mapster/Interfaces/IMapper.cs
index f32b4b51..201420b0 100644
--- a/src/Mapster/Interfaces/IMapper.cs
+++ b/src/Mapster/Interfaces/IMapper.cs
@@ -7,11 +7,65 @@ namespace MapsterMapper
     public interface IMapper
     {
         TypeAdapterConfig Config { get; }
-        ITypeAdapterBuilder<TSource> From<TSource>(TSource source);
-        TDestination Map<TDestination>(object source);
-        TDestination Map<TSource, TDestination>(TSource source);
-        TDestination Map<TSource, TDestination>(TSource source, TDestination destination);
-        object Map(object source, Type sourceType, Type destinationType);
-        object Map(object source, object destination, Type sourceType, Type destinationType);
+
+
+		/// <summary>
+		/// Create mapping builder.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to create mapping builder.</typeparam>
+		/// <param name="source">Source object to create mapping builder.</param>
+		/// <returns>Adapter builder type.</returns>
+		ITypeAdapterBuilder<TSource> From<TSource>(TSource source);
+
+
+		/// <summary>
+		/// Perform mapping from source object to type of destination.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to create mapping builder.</typeparam>
+		/// <param name="source">Source object to create mapping builder.</param>
+		/// <returns>Type of destination object that mapped.</returns>
+		TDestination Map<TDestination>(object source);
+
+
+		/// <summary>
+		/// Perform mapping from type of source to type of destination.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to map.</typeparam>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="source">Source object to map.</param>
+		/// <returns>Type of destination object that mapped.</returns>
+		TDestination Map<TSource, TDestination>(TSource source);
+
+
+		/// <summary>
+		/// Perform mapping from type of source to type of destination.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to map.</typeparam>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="destination">Destination object to map.</param>
+		/// <returns>Type of destination object that mapped.</returns>
+		TDestination Map<TSource, TDestination>(TSource source, TDestination destination);
+
+
+		/// <summary>
+		/// Perform mapping source object from source type to destination type.
+		/// </summary>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="sourceType">Source type to map.</param>
+		/// <param name="destinationType">Destination type to map.</param>
+		/// <returns>Mapped object.</returns>
+		object Map(object source, Type sourceType, Type destinationType);
+
+
+		/// <summary>
+		/// Perform mapping source object from source type to destination type.
+		/// </summary>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="destination">Destination object to map.</param>
+		/// <param name="sourceType">Source type to map.</param>
+		/// <param name="destinationType">Destination type to map.</param>
+		/// <returns>Mapped object.</returns>
+		object Map(object source, object destination, Type sourceType, Type destinationType);
     }
 }
diff --git a/src/Mapster/Mapper.cs b/src/Mapster/Mapper.cs
index d63f6213..2694c7f3 100644
--- a/src/Mapster/Mapper.cs
+++ b/src/Mapster/Mapper.cs
@@ -16,12 +16,25 @@ public Mapper(TypeAdapterConfig config)
             Config = config;
         }
 
-        public virtual ITypeAdapterBuilder<TSource> From<TSource>(TSource source)
+		/// <summary>
+		/// Create mapping builder.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to create mapping builder.</typeparam>
+		/// <param name="source"></param>
+		/// <returns></returns>
+		public virtual ITypeAdapterBuilder<TSource> From<TSource>(TSource source)
         {
             return TypeAdapter.BuildAdapter(source, Config);
         }
 
-        public virtual TDestination Map<TDestination>(object source)
+
+		/// <summary>
+		/// Perform mapping source object to type of destination.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to perform mapping</typeparam>
+		/// <param name="source">Source object to perform mapping.</param>
+		/// <returns>type of destination mapping result.</returns>
+		public virtual TDestination Map<TDestination>(object source)
         {
             // ReSharper disable once ConditionIsAlwaysTrueOrFalse
             if (source == null)
@@ -31,18 +44,43 @@ public virtual TDestination Map<TDestination>(object source)
             return fn(source);
         }
 
-        public virtual TDestination Map<TSource, TDestination>(TSource source)
+
+		/// <summary>
+		/// Perform mapping from type of source to type of destination.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to map.</typeparam>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="source"></param>
+		/// <returns>type of destination mapping result</returns>
+		public virtual TDestination Map<TSource, TDestination>(TSource source)
         {
             var fn = Config.GetMapFunction<TSource, TDestination>();
             return fn(source);
         }
 
-        public virtual TDestination Map<TSource, TDestination>(TSource source, TDestination destination)
+
+		/// <summary>
+		/// Perform mapping from type of source to type of destination.
+		/// </summary>
+		/// <typeparam name="TSource">Source type to map.</typeparam>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="destination">Destination type to map.</param>
+		/// <returns>type of destination mapping result</returns>
+		public virtual TDestination Map<TSource, TDestination>(TSource source, TDestination destination)
         {
             var fn = Config.GetMapToTargetFunction<TSource, TDestination>();
             return fn(source, destination);
         }
 
+
+        /// <summary>
+        /// Perform mapping source object from source type to destination type.
+        /// </summary>
+        /// <param name="source">Source object to map.</param>
+        /// <param name="sourceType">Source type to map.</param>
+        /// <param name="destinationType">Destination type to map.</param>
+        /// <returns>mapped result object</returns>
         public virtual object Map(object source, Type sourceType, Type destinationType)
         {
             var del = Config.GetMapFunction(sourceType, destinationType);
@@ -59,7 +97,16 @@ public virtual object Map(object source, Type sourceType, Type destinationType)
             }
         }
 
-        public virtual object Map(object source, object destination, Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Perform mapping source object to destination object from source type to destination type.
+		/// </summary>
+		/// <param name="source">Source object to map.</param>
+		/// <param name="destination">Destination object to map.</param>
+		/// <param name="sourceType">Source type to map.</param>
+		/// <param name="destinationType">Destination type to map.</param>
+		/// <returns>mapped result object</returns>
+		public virtual object Map(object source, object destination, Type sourceType, Type destinationType)
         {
             var del = Config.GetMapToTargetFunction(sourceType, destinationType);
             if (sourceType.GetTypeInfo().IsVisible && destinationType.GetTypeInfo().IsVisible)
diff --git a/src/Mapster/TypeAdapterBuilder.cs b/src/Mapster/TypeAdapterBuilder.cs
index 30c76880..26f93efa 100644
--- a/src/Mapster/TypeAdapterBuilder.cs
+++ b/src/Mapster/TypeAdapterBuilder.cs
@@ -25,7 +25,15 @@ internal TypeAdapterBuilder(TSource source, TypeAdapterConfig config)
             Config = config;
         }
 
-        [SuppressMessage("ReSharper", "ExplicitCallerInfoArgument")]
+
+		/// <summary>
+		/// Allow you to keep config and mapping inline.
+		/// </summary>
+		/// <param name="action"></param>
+		/// <param name="key1"></param>
+		/// <param name="key2"></param>
+		/// <returns></returns>
+		[SuppressMessage("ReSharper", "ExplicitCallerInfoArgument")]
         public ITypeAdapterBuilder<TSource> ForkConfig(Action<TypeAdapterConfig> action,
 #if !NET40
             [CallerFilePath]
@@ -40,7 +48,14 @@ public ITypeAdapterBuilder<TSource> ForkConfig(Action<TypeAdapterConfig> action,
             return this;
         }
 
-        public ITypeAdapterBuilder<TSource> AddParameters(string name, object value)
+
+		/// <summary>
+		/// Passing runtime value.
+		/// </summary>
+		/// <param name="name">Parameter name.</param>
+		/// <param name="value">Parameter value</param>
+		/// <returns></returns>
+		public ITypeAdapterBuilder<TSource> AddParameters(string name, object value)
         {
             Parameters.Add(name, value);
             return this;
@@ -58,9 +73,14 @@ private MapContextScope CreateMapContextScope()
             return scope;
         }
 
-        MapContextScope IAdapterBuilder.CreateMapContextScope() => CreateMapContextScope();
 
-        public TDestination AdaptToType<TDestination>()
+        MapContextScope IAdapterBuilder.CreateMapContextScope() => CreateMapContextScope();
+		/// <summary>
+		/// Mapping to new type using in adapter builder scenario.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to adopt.</typeparam>
+		/// <returns></returns>
+		public TDestination AdaptToType<TDestination>()
         {
             if (_parameters == null)
                 return Map<TDestination>();
@@ -71,13 +91,26 @@ public TDestination AdaptToType<TDestination>()
             }
         }
 
-        private TDestination Map<TDestination>()
+
+		/// <summary>
+		/// Perform mapping to type of destination in adapter builder scenario.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to map.</typeparam>
+		/// <returns></returns>
+		private TDestination Map<TDestination>()
         {
             var fn = Config.GetMapFunction<TSource, TDestination>();
             return fn(Source);
         }
 
-        public TDestination AdaptTo<TDestination>(TDestination destination)
+
+		/// <summary>
+		/// Mapping to existing object in adapter builder scenario.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to adopt.</typeparam>
+		/// <param name="destination"></param>
+		/// <returns></returns>
+		public TDestination AdaptTo<TDestination>(TDestination destination)
         {
             if (_parameters == null)
                 return MapToTarget(destination);
@@ -94,19 +127,37 @@ private TDestination MapToTarget<TDestination>(TDestination destination)
             return fn(Source, destination);
         }
 
-        public Expression<Func<TSource, TDestination>> CreateMapExpression<TDestination>()
+
+		/// <summary>
+		/// Get mapping expression.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to create map expression.</typeparam>
+		/// <returns></returns>
+		public Expression<Func<TSource, TDestination>> CreateMapExpression<TDestination>()
         {
             var tuple = new TypeTuple(typeof(TSource), typeof(TDestination));
             return (Expression<Func<TSource, TDestination>>) Config.CreateMapExpression(tuple, MapType.Map);
         }
 
-        public Expression<Func<TSource, TDestination, TDestination>> CreateMapToTargetExpression<TDestination>()
+
+		/// <summary>
+		/// Get mapping to existing object expression.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to create map to target expression.</typeparam>
+		/// <returns></returns>
+		public Expression<Func<TSource, TDestination, TDestination>> CreateMapToTargetExpression<TDestination>()
         {
             var tuple = new TypeTuple(typeof(TSource), typeof(TDestination));
             return (Expression<Func<TSource, TDestination, TDestination>>) Config.CreateMapExpression(tuple, MapType.MapToTarget);
         }
 
-        public Expression<Func<TSource, TDestination>> CreateProjectionExpression<TDestination>()
+
+		/// <summary>
+		/// Get mapping from queryable expression.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type to create projection expression.</typeparam>
+		/// <returns></returns>
+		public Expression<Func<TSource, TDestination>> CreateProjectionExpression<TDestination>()
         {
             var tuple = new TypeTuple(typeof(TSource), typeof(TDestination));
             return (Expression<Func<TSource, TDestination>>) Config.CreateMapExpression(tuple, MapType.Projection);
diff --git a/src/Mapster/TypeAdapterConfig.cs b/src/Mapster/TypeAdapterConfig.cs
index 47de4086..f5ebbb3a 100644
--- a/src/Mapster/TypeAdapterConfig.cs
+++ b/src/Mapster/TypeAdapterConfig.cs
@@ -103,7 +103,13 @@ public TypeAdapterConfig()
             });
         }
 
-        public TypeAdapterSetter When(Func<Type, Type, MapType, bool> canMap)
+
+		/// <summary>
+		/// allows you to specify conditions for when a mapping should occur based on source and destination types and the mapping type.
+		/// </summary>
+		/// <param name="canMap"></param>
+		/// <returns></returns>
+		public TypeAdapterSetter When(Func<Type, Type, MapType, bool> canMap)
         {
             var rule = new TypeAdapterRule
             {
@@ -114,7 +120,13 @@ public TypeAdapterSetter When(Func<Type, Type, MapType, bool> canMap)
             return new TypeAdapterSetter(rule.Settings, this);
         }
 
-        public TypeAdapterSetter When(Func<PreCompileArgument, bool> canMap)
+
+		/// <summary>
+		/// allows you to specify conditions for when a mapping should occur based on PreCompileArgument delegate
+		/// </summary>
+		/// <param name="canMap"></param>
+		/// <returns></returns>
+		public TypeAdapterSetter When(Func<PreCompileArgument, bool> canMap)
         {
             var rule = new TypeAdapterRule
             {
@@ -125,40 +137,80 @@ public TypeAdapterSetter When(Func<PreCompileArgument, bool> canMap)
             return new TypeAdapterSetter(rule.Settings, this);
         }
 
-        public TypeAdapterSetter<TSource, TDestination> NewConfig<TSource, TDestination>()
+
+		/// <summary>
+		/// Creates a new configuration for mapping between source and destination types.
+		/// </summary>
+		/// <typeparam name="TSource">Source type.</typeparam>
+		/// <typeparam name="TDestination">Destination type.</typeparam>
+		/// <returns></returns>
+		public TypeAdapterSetter<TSource, TDestination> NewConfig<TSource, TDestination>()
         {
             Remove(typeof(TSource), typeof(TDestination));
             return ForType<TSource, TDestination>();
         }
 
-        public TypeAdapterSetter NewConfig(Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Creates a new configuration for mapping between source and destination types.
+		/// </summary>
+		/// <param name="sourceType">Source type to create new configuration.</param>
+		/// <param name="destinationType">Destination type to create new configuration.</param>
+		/// <returns></returns>
+		public TypeAdapterSetter NewConfig(Type sourceType, Type destinationType)
         {
             Remove(sourceType, destinationType);
             return ForType(sourceType, destinationType);
         }
 
-        public TypeAdapterSetter<TSource, TDestination> ForType<TSource, TDestination>()
+
+		/// <summary>
+		/// Configures a mapping for a specific source and destination type pair.
+		/// </summary>
+		/// <typeparam name="TSource"></typeparam>
+		/// <typeparam name="TDestination"></typeparam>
+		/// <returns></returns>
+		public TypeAdapterSetter<TSource, TDestination> ForType<TSource, TDestination>()
         {
             var key = new TypeTuple(typeof(TSource), typeof(TDestination));
             var settings = GetSettings(key);
             return new TypeAdapterSetter<TSource, TDestination>(settings, this);
         }
 
-        public TypeAdapterSetter ForType(Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Configures a mapping for a specific source and destination type pair.
+		/// </summary>
+		/// <param name="sourceType"></param>
+		/// <param name="destinationType"></param>
+		/// <returns></returns>
+		public TypeAdapterSetter ForType(Type sourceType, Type destinationType)
         {
             var key = new TypeTuple(sourceType, destinationType);
             var settings = GetSettings(key);
             return new TypeAdapterSetter(settings, this);
         }
 
-        public TypeAdapterSetter<TDestination> ForDestinationType<TDestination>()
+
+		/// <summary>
+		/// Configures a mapping for a specific destination type.
+		/// </summary>
+		/// <typeparam name="TDestination">Destination type.</typeparam>
+		/// <returns></returns>
+		public TypeAdapterSetter<TDestination> ForDestinationType<TDestination>()
         {
             var key = new TypeTuple(typeof(void), typeof(TDestination));
             var settings = GetSettings(key);
             return new TypeAdapterSetter<TDestination>(settings, this);
         }
 
-        public TypeAdapterSetter ForDestinationType(Type destinationType)
+
+		/// <summary>
+		/// Configures a mapping for a specific destination type.
+		/// </summary>
+		/// <param name="destinationType">Destination type.</param>
+		/// <returns></returns>
+		public TypeAdapterSetter ForDestinationType(Type destinationType)
         {
             var key = new TypeTuple(typeof(void), destinationType);
             var settings = GetSettings(key);
@@ -582,7 +634,13 @@ private CompileArgument GetCompileArgument(TypeTuple tuple, MapType mapType, Com
             };
         }
 
-        public void Compile(bool failFast = true)
+
+		/// <summary>
+		/// Validates and cache mapping instructions.
+		/// </summary>
+		/// <param name="failFast">A boolean parameter that determines whether exceptions should be thrown immediately when mapping errors occur or whether to collect and aggregate them. The default value is true.</param>
+		/// <exception cref="AggregateException"></exception>
+		public void Compile(bool failFast = true)
         {
             var exceptions = new List<Exception>();
             var keys = RuleMap.Keys.ToList();
@@ -614,7 +672,13 @@ public void Compile(bool failFast = true)
             }
         }
 
-        public void Compile(Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Validates and cache mapping instructions.
+		/// </summary>
+		/// <param name="sourceType">Source type to compile.</param>
+		/// <param name="destinationType">Destination type to compile.</param>
+		public void Compile(Type sourceType, Type destinationType)
         {
             var tuple = new TypeTuple(sourceType, destinationType);
             _mapDict[tuple] = Compiler(CreateMapExpression(tuple, MapType.Map));
@@ -626,7 +690,11 @@ public void Compile(Type sourceType, Type destinationType)
             }
         }
 
-        public void CompileProjection()
+
+		/// <summary>
+		/// Validates and cache mapping instructions for queryable.
+		/// </summary>
+		public void CompileProjection()
         {
             var keys = RuleMap.Keys.ToList();
             foreach (var key in keys)
@@ -635,13 +703,25 @@ public void CompileProjection()
             }
         }
 
-        public void CompileProjection(Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Validates and cache mapping instructions for queryable.
+		/// </summary>
+		/// <param name="sourceType">Source type to compile.</param>
+		/// <param name="destinationType">Destination type to compile.</param>
+		public void CompileProjection(Type sourceType, Type destinationType)
         {
             var tuple = new TypeTuple(sourceType, destinationType);
             _projectionDict[tuple] = CreateProjectionCallExpression(tuple);
         }
 
-        public IList<IRegister> Scan(params Assembly[] assemblies)
+
+		/// <summary>
+		/// Scans and registers mappings from specified assemblies.
+		/// </summary>
+		/// <param name="assemblies">assemblies to scan.</param>
+		/// <returns>A list of registered mappings</returns>
+		public IList<IRegister> Scan(params Assembly[] assemblies)
         {
             List<IRegister> registers = assemblies.Select(assembly => assembly.GetLoadableTypes()
                 .Where(x => typeof(IRegister).GetTypeInfo().IsAssignableFrom(x.GetTypeInfo()) && x.GetTypeInfo().IsClass && !x.GetTypeInfo().IsAbstract))
@@ -652,12 +732,22 @@ public IList<IRegister> Scan(params Assembly[] assemblies)
             return registers;
         }
 
-        public void Apply(IEnumerable<Lazy<IRegister>> registers)
+
+		/// <summary>
+		/// Applies type mappings.
+		/// </summary>
+		/// <param name="registers">collection of IRegister interface to apply mapping.</param>
+		public void Apply(IEnumerable<Lazy<IRegister>> registers)
         {
             Apply(registers.Select(register => register.Value));
         }
 
-        public void Apply(IEnumerable<IRegister> registers)
+
+		/// <summary>
+		/// Applies type mappings.
+		/// </summary>
+		/// <param name="registers">collection of IRegister interface to apply mapping.</param>
+		public void Apply(IEnumerable<IRegister> registers)
         {
             foreach (IRegister register in registers)
             {
@@ -665,7 +755,12 @@ public void Apply(IEnumerable<IRegister> registers)
             }
         }
 
-        public void Apply(params IRegister[] registers)
+
+		/// <summary>
+		/// Applies type mappings.
+		/// </summary>
+		/// <param name="registers">IRegister interface params to apply mapping.</param>
+		public void Apply(params IRegister[] registers)
         {
             foreach (IRegister register in registers)
             {
@@ -673,7 +768,11 @@ public void Apply(params IRegister[] registers)
             }
         }
 
-        internal void Clear()
+
+		/// <summary>
+		/// Clears all type mapping rules and settings
+		/// </summary>
+		internal void Clear()
         {
             var keys = RuleMap.Keys.ToList();
             foreach (var key in keys)
@@ -682,7 +781,13 @@ internal void Clear()
             }
         }
 
-        internal void Remove(Type sourceType, Type destinationType)
+
+		/// <summary>
+		/// Removes a specific type mapping rule.
+		/// </summary>
+		/// <param name="sourceType">Source type to remove.</param>
+		/// <param name="destinationType">Destination type to remove.</param>
+		internal void Remove(Type sourceType, Type destinationType)
         {
             var key = new TypeTuple(sourceType, destinationType);
             Remove(key);
@@ -706,7 +811,13 @@ private void Remove(TypeTuple key)
                 .MapWith(src => src.Clone(), true);
             return config;
         });
-        public TypeAdapterConfig Clone()
+
+
+		/// <summary>
+		/// Clones the current TypeAdapterConfig.
+		/// </summary>
+		/// <returns></returns>
+		public TypeAdapterConfig Clone()
         {
             var fn = _cloneConfig.Value.GetMapFunction<TypeAdapterConfig, TypeAdapterConfig>();
             return fn(this);
@@ -737,17 +848,30 @@ public TypeAdapterConfig Fork(Action<TypeAdapterConfig> action,
 
     public static class TypeAdapterConfig<TSource, TDestination>
     {
-        public static TypeAdapterSetter<TSource, TDestination> NewConfig()
+		/// <summary>
+		///  Creates a new configuration for mapping between the source and destination types.
+		/// </summary>
+		/// <returns></returns>
+		public static TypeAdapterSetter<TSource, TDestination> NewConfig()
         {
             return TypeAdapterConfig.GlobalSettings.NewConfig<TSource, TDestination>();
         }
 
-        public static TypeAdapterSetter<TSource, TDestination> ForType()
+
+		/// <summary>
+		/// Creates a configuration for mapping between the source and destination types.
+		/// </summary>
+		/// <returns></returns>
+		public static TypeAdapterSetter<TSource, TDestination> ForType()
         {
             return TypeAdapterConfig.GlobalSettings.ForType<TSource, TDestination>();
         }
 
-        public static void Clear()
+
+		/// <summary>
+		/// Clears the type mapping configuration for the specified source and destination types.
+		/// </summary>
+		public static void Clear()
         {
             TypeAdapterConfig.GlobalSettings.Remove(typeof(TSource), typeof(TDestination));
         }