--- Smdn.Net.Imap4.Client-2.0alpha1-netstandard2.0.apilist.cs	2019-03-23 14:49:58.000000000 +0900
+++ Smdn.Net.Imap4.Client-2.0alpha2-netstandard2.0.apilist.cs	2019-03-23 14:50:01.000000000 +0900
@@ -1,3093 +1,3450 @@
-// Smdn.Net.Imap4.Client-2.0alpha1 (netstandard2.0)
+// Smdn.Net.Imap4.Client-2.0alpha2 (netstandard2.0)
 //   Name: Smdn.Net.Imap4.Client
 //   TargetFramework: .NETStandard,Version=v2.0
 //   AssemblyVersion: 2.0.0.0
-//   InformationalVersion: 2.0alpha1 (netstandard2.0)
+//   InformationalVersion: 2.0alpha2 (netstandard2.0)
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Net;
 using System.Net.Mail;
 using System.Net.Security;
 using System.Runtime.Serialization;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Smdn;
 using Smdn.Formats.Mime;
 using Smdn.IO.Streams.LineOriented;
 using Smdn.Net.Connection;
 using Smdn.Net.Imap4;
 using Smdn.Net.Imap4.Client;
 using Smdn.Net.Imap4.Protocol;
 using Smdn.Net.Imap4.Protocol.DataStructures;
 using Smdn.Net.Imap4.Protocol.DataStructures.BodyStructures;
 using Smdn.Net.Imap4.Protocol.DataStructures.MessageAttributes;
 using Smdn.Net.Imap4.Protocol.Session;
 using Smdn.Net.Imap4.Protocol.Strings;
 using Smdn.Net.Imap4.Protocol.Transmission;
 using Smdn.Net.Imap4.Urls;
-using Smdn.Net.MessageAccessProtocols;
+using Smdn.Net.MessageAccessProtocols.Strings;
 using Smdn.Security.Authentication.Sasl.Client;
 using Smdn.Text;
 using Smdn.Text.Encodings;
 
 namespace Smdn.Formats.Mime {
   public static class MimeHeaderUtils {
     public static string GetDecodedParameterValue(string paramName, IReadOnlyDictionary<string, string> parameters, EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
     public static string GetDecodedValue(string rawValue, EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
     public static string GetDecodedValue(string rawValue, EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported, out Encoding charset) {}
   }
 }
 
 namespace Smdn.Net.Imap4 {
   [Serializable]
   public class ImapException : Exception {
     protected ImapException(SerializationInfo info, StreamingContext context) {}
     public ImapException() {}
     public ImapException(string message) {}
     public ImapException(string message, Exception innerException) {}
   }
 }
 
 namespace Smdn.Net.Imap4.Client {
   [Flags]
   public enum ImapMailboxListOptions : int {
     Default = 0x00000000,
     Remote = 0x00000002,
     RequestStatus = 0x00000008,
     SubscribedOnly = 0x00000001,
     TopLevelOnly = 0x00000004,
   }
 
   [Flags]
   public enum ImapMessageFetchAttributeOptions : int {
     AllAttributes = 0x00000003,
     Default = 0x00000000,
     DynamicAttributes = 0x00000002,
     None = 0x00000000,
     StaticAttributes = 0x00000001,
   }
 
   [Flags]
   public enum ImapMessageFetchBodyOptions : int {
     DecodeContent = 0x00000002,
     Default = 0x00000000,
     OmitHeader = 0x00000004,
     SetSeen = 0x00000001,
   }
 
   public enum ImapSpecialMailbox : int {
     All = 0,
     Archive = 1,
     Drafts = 2,
     Flagged = 3,
     Junk = 4,
     Sent = 5,
     Trash = 6,
   }
 
   public class ImapAlertReceivedEventArgs : EventArgs {
     public ImapAlertReceivedEventArgs(string alert, ImapResponseCondition condition) {}
 
     public string Alert { get; }
     public ImapResponseCondition Condition { get; }
   }
 
   public class ImapClient : IDisposable {
     public event EventHandler<ImapAlertReceivedEventArgs> AlertReceived;
     [Obsolete("use ExistingMessageCountChanged instead")]
     public event EventHandler<ImapMailboxSizeChangedEventArgs> ExistMessageCountChanged;
     public event EventHandler<ImapMailboxSizeChangedEventArgs> ExistingMessageCountChanged;
     public event EventHandler<ImapMessageStatusChangedEventArgs> MessageDeleted;
     public event EventHandler<ImapMessageStatusChangedEventArgs> MessageStatusChanged;
     public event EventHandler<ImapMailboxSizeChangedEventArgs> RecentMessageCountChanged;
 
     public ImapClient() {}
     public ImapClient(ImapClientProfile profile) {}
     public ImapClient(Uri authority) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapClient(string host, bool securePort, string userName) {}
     public ImapClient(string host, int port = -1, bool securePort = false, string userName = null, string authType = null, int timeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool useTlsIfAvailable = true, IEnumerable<string> usingSaslMechanisms = null, bool allowInsecureLogin = false) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapClient(string host, int port, string userName) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapClient(string host, int port, string userName, string authType) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapClient(string host, string userName) {}
 
     public ISet<ImapCapability> DisabledCapabilities { get; }
     public bool IsBusy { get; }
     public bool IsConnected { get; }
     public bool IsIdling { get; }
     public bool IsSecureSession { get; }
     [Obsolete("use OpeningMailbox instead")]
     public ImapOpenMailbox OpenedMailbox { get; }
     public ImapOpenMailbox OpeningMailbox { get; }
     public ImapClientProfile Profile { get; }
     public int ReceiveTimeout { get; set; }
     public int SendTimeout { get; set; }
     public IReadOnlyStringSet<ImapCapability> ServerCapabilities { get; }
     public IReadOnlyDictionary<string, string> ServerID { get; }
     public ImapNamespace ServerNamespace { get; }
     public ISynchronizeInvoke SynchronizingObject { get; set; }
     public int Timeout { get; set; }
 
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public IAsyncResult BeginConnect(ICredentialsByHost credentials, AsyncCallback asyncCallback, object asyncState) {}
     public IAsyncResult BeginConnect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, AsyncCallback asyncCallback, object asyncState) {}
     public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public IAsyncResult BeginConnect(string password, AsyncCallback asyncCallback, object asyncState) {}
     public IAsyncResult BeginConnect(string password, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
     public void CloseMailbox() {}
     public Task CloseMailboxAsync() {}
     public string CombineMailboxName(IEnumerable<string> names) {}
     public string CombineMailboxName(params string[] names) {}
     public string CombineMailboxName(string name1, string name2) {}
     public string CombineMailboxName(string name1, string name2, string name3) {}
     public string CombineMailboxName(string name1, string name2, string name3, string name4) {}
     public void Connect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
     public void Connect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
     public void Connect(string password, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
     public Task ConnectAsync(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
     public Task ConnectAsync(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
     public Task ConnectAsync(string password, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
     public static ImapMailbox CopyMailbox(ImapMailbox mailbox, ImapClient destinationSession, string destinationMailboxName, bool recursive = false, bool subscribe = false) {}
     public static void CopyMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox, bool recursive = false, bool subscribe = false) {}
     public ImapMailbox CreateMailbox(string mailboxName, bool subscribeIfCreated = false) {}
     public Task<ImapMailbox> CreateMailboxAsync(string mailboxName, bool subscribeIfCreated = false) {}
     public void Disconnect(bool logout = false) {}
     public void EndConnect(IAsyncResult asyncResult) {}
     public ImapMailbox GetInbox(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<ImapMailbox> GetInboxAsync(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public ImapMailbox GetMailbox(ImapSpecialMailbox specialMailbox, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public ImapMailbox GetMailbox(string mailboxName, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<ImapMailbox> GetMailboxAsync(ImapSpecialMailbox specialMailbox, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<ImapMailbox> GetMailboxAsync(string mailboxName, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public IReadOnlyList<ImapMailbox> GetMailboxes(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<IReadOnlyList<ImapMailbox>> GetMailboxesAsync(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapMailbox GetOrCreateMailbox(string mailboxName, ImapMailboxListOptions options) {}
     public ImapMailbox GetOrCreateMailbox(string mailboxName, bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<ImapMailbox> GetOrCreateMailboxAsync(string mailboxName, ImapMailboxListOptions options) {}
     public Task<ImapMailbox> GetOrCreateMailboxAsync(string mailboxName, bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public ImapQuota GetQuota(string quotaRoot) {}
     public Task<ImapQuota> GetQuotaAsync(string quotaRoot) {}
     public double GetQuotaUsage(string quotaRoot, string resourceName) {}
     public Task<double> GetQuotaUsageAsync(string quotaRoot, string resourceName) {}
     public void Logout() {}
     public static ImapMailbox MoveMailbox(ImapMailbox mailbox, ImapClient destinationSession, string destinationMailboxName, bool recursive = false, bool subscribe = false) {}
     public static void MoveMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox, bool recursive = false, bool subscribe = false) {}
     public ImapOpenMailbox OpenInbox(bool asReadOnly = false) {}
     public Task<ImapOpenMailbox> OpenInboxAsync(bool asReadOnly = false) {}
     public ImapOpenMailbox OpenMailbox(ImapMailbox mailbox, bool asReadOnly = false) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapOpenMailbox OpenMailbox(ImapSpecialMailbox specialMailbox, ImapMailboxListOptions options) {}
     public ImapOpenMailbox OpenMailbox(ImapSpecialMailbox specialMailbox, bool asReadOnly = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapOpenMailbox OpenMailbox(string mailboxName, ImapMailboxListOptions options) {}
     public ImapOpenMailbox OpenMailbox(string mailboxName, bool asReadOnly = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("use OpenInboxAsync() instead")]
     public Task<ImapOpenMailbox> OpenMailboxAsync() {}
     public Task<ImapOpenMailbox> OpenMailboxAsync(ImapMailbox mailbox, bool asReadOnly = false) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<ImapOpenMailbox> OpenMailboxAsync(ImapSpecialMailbox specialMailbox, ImapMailboxListOptions options) {}
     public Task<ImapOpenMailbox> OpenMailboxAsync(ImapSpecialMailbox specialMailbox, bool asReadOnly = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("use OpenInboxAsync() instead")]
     public Task<ImapOpenMailbox> OpenMailboxAsync(bool asReadOnly) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<ImapOpenMailbox> OpenMailboxAsync(string mailboxName, ImapMailboxListOptions options) {}
     public Task<ImapOpenMailbox> OpenMailboxAsync(string mailboxName, bool asReadOnly = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapOpenMailbox OpenOrCreateMailbox(string mailboxName, ImapMailboxListOptions options) {}
     public ImapOpenMailbox OpenOrCreateMailbox(string mailboxName, bool subscribeIfCreated = false, bool asReadOnly = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<ImapOpenMailbox> OpenOrCreateMailboxAsync(string mailboxName, ImapMailboxListOptions options) {}
     public Task<ImapOpenMailbox> OpenOrCreateMailboxAsync(string mailboxName, bool subscribeIfCreated = false, bool asReadOnly = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
-    internal protected ImapCommandResult ProcessResult(ImapCommandResult result) {}
-    internal protected virtual ImapCommandResult ProcessResult(ImapCommandResult result, Func<ImapTaggedStatusResponse, bool> throwIfErrorResponse) {}
+    internal protected virtual ImapCommandResult ProcessResult(ImapCommandResult result, Func<ImapTaggedStatusResponse, bool> throwIfErrorResponse = null) {}
     public void Refresh() {}
     public Task RefreshAsync() {}
     void IDisposable.Dispose() {}
     public override string ToString() {}
   }
 
   [Serializable]
   public class ImapClientProfile :
     ICloneable,
     IImapSessionProfile,
     ISerializable
   {
     protected ImapClientProfile(SerializationInfo info, StreamingContext context) {}
     public ImapClientProfile() {}
     public ImapClientProfile(Uri authority) {}
     public ImapClientProfile(string host, int port = -1, bool securePort = false, string userName = null, string authType = null, int timeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool useTlsIfAvailable = true, IEnumerable<string> usingSaslMechanisms = null, bool allowInsecureLogin = false) {}
 
     public bool AllowInsecureLogin { get; set; }
     public string AuthType { get; set; }
     public Uri Authority { get; }
     public string Host { get; set; }
     public int Port { get; set; }
     public int ReceiveTimeout { get; set; }
     public bool SecurePort { get; set; }
     public int SendTimeout { get; set; }
     ICredentialsByHost IImapSessionProfile.Credentials { get; }
     bool IImapSessionProfile.UseDeflateIfAvailable { get; }
     IReadOnlyList<string> IImapSessionProfile.UsingSaslMechanisms { get; }
     public int Timeout { get; set; }
     public bool UseTlsIfAvailable { get; set; }
     public string UserName { get; set; }
     public IList<string> UsingSaslMechanisms { get; }
 
     public ImapClientProfile Clone() {}
     public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
     public void SetUsingSaslMechanisms(IEnumerable<string> mechanisms) {}
     object ICloneable.Clone() {}
   }
 
   public class ImapMailbox : IImapUrl {
     public bool CanHaveChild { get; }
     protected bool CanNotHaveChild { get; }
     public ImapClient Client { get; }
     [Obsolete("use ExistingMessageCount instead")]
     public long ExistMessageCount { get; }
     public long ExistingMessageCount { get; }
     public bool Exists { get; }
     public IReadOnlyStringSet<ImapMailboxFlag> Flags { get; }
     public string FullName { get; }
     public ulong HighestModSeq { get; }
     public bool IsInbox { get; }
     public bool IsModSequencesAvailable { get; }
     public virtual bool IsOpen { get; }
     public bool IsUnselectable { get; }
     internal protected ImapMailboxStatus Mailbox { get; }
     public string MailboxSeparator { get; }
     public string Name { get; }
     public long NextUid { get; }
     public string ParentMailboxName { get; }
     public long RecentMessageCount { get; }
     public long UidValidity { get; }
     public long UnseenMessageCount { get; }
     public Uri Url { get; }
 
     public void AppendMessage(Action<Stream> writeMessage, DateTimeOffset? appendDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void AppendMessage(DateTimeOffset appendDate, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void AppendMessage(DateTimeOffset appendDate, IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void AppendMessage(IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     public void AppendMessage(IImapAppendMessage message) {}
     public void AppendMessage(ImapMessage message) {}
     public void AppendMessage(Stream stream, DateTimeOffset? appendDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void AppendMessage(Stream stream, IEnumerable<ImapMessageFlag> flags) {}
     public void AppendMessage(long length, Action<Stream> writeMessage, DateTimeOffset? appendDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void AppendMessage(long length, DateTimeOffset appendDate, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void AppendMessage(long length, DateTimeOffset appendDate, IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void AppendMessage(long length, IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     public Task AppendMessageAsync(Action<Stream> writeMessage, DateTimeOffset? appendDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task AppendMessageAsync(DateTimeOffset appendDate, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task AppendMessageAsync(DateTimeOffset appendDate, IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task AppendMessageAsync(IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     public Task AppendMessageAsync(IImapAppendMessage message) {}
     public Task AppendMessageAsync(ImapMessage message) {}
     public Task AppendMessageAsync(Stream stream, DateTimeOffset? appendDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task AppendMessageAsync(Stream stream, IEnumerable<ImapMessageFlag> flags) {}
     public Task AppendMessageAsync(long length, Action<Stream> writeMessage, DateTimeOffset? appendDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task AppendMessageAsync(long length, DateTimeOffset appendDate, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task AppendMessageAsync(long length, DateTimeOffset appendDate, IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task AppendMessageAsync(long length, IEnumerable<ImapMessageFlag> flags, Action<Stream> writeMessage) {}
     public void AppendMessages(IEnumerable<IImapAppendMessage> messages) {}
     public Task AppendMessagesAsync(IEnumerable<IImapAppendMessage> messages) {}
     public static ImapMailbox Create(ImapClient client, string mailboxName, bool subscribe = false) {}
     public void Create(bool subscribe = false) {}
     public Task CreateAsync(bool subscribe = false) {}
     public static Task<ImapMailbox> CreateAsync(ImapClient client, string mailboxName, bool subscribe = false) {}
     public ImapMailbox CreateChild(string name, bool subscribe = false) {}
     public Task<ImapMailbox> CreateChildAsync(string name, bool subscribe = false) {}
     public void Delete(bool unsubscribe = false) {}
     public Task DeleteAsync(bool unsubscribe = false) {}
     public ImapMailbox GetChild(string name, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<ImapMailbox> GetChildAsync(string name, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public IReadOnlyList<ImapMailbox> GetChildren(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<IReadOnlyList<ImapMailbox>> GetChildrenAsync(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public string GetFullNameOf(IEnumerable<string> inferiorNames) {}
     public string GetFullNameOf(params string[] inferiorNames) {}
     public string GetFullNameOf(string inferiorName) {}
     public string GetFullNameOf(string inferiorName1, string inferiorName2) {}
     public string GetFullNameOf(string inferiorName1, string inferiorName2, string inferiorName3) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapMailbox GetOrCreateChild(string name, ImapMailboxListOptions options) {}
     public ImapMailbox GetOrCreateChild(string name, bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<ImapMailbox> GetOrCreateChildAsync(string name, ImapMailboxListOptions options) {}
     public Task<ImapMailbox> GetOrCreateChildAsync(string name, bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public ImapMailbox GetOrCreateParent(ImapMailboxListOptions options) {}
     public ImapMailbox GetOrCreateParent(bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<ImapMailbox> GetOrCreateParentAsync(ImapMailboxListOptions options) {}
     public Task<ImapMailbox> GetOrCreateParentAsync(bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public ImapMailbox GetParent(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public Task<ImapMailbox> GetParentAsync(ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
     public IReadOnlyList<ImapQuota> GetQuota() {}
     public Task<IReadOnlyList<ImapQuota>> GetQuotaAsync() {}
     public void MoveTo(ImapMailbox destinationMailbox, bool subscribe = false) {}
     public void MoveTo(string newMailboxName, bool subscribe = false) {}
     public Task MoveToAsync(ImapMailbox destinationMailbox, bool subscribe = false) {}
     public Task MoveToAsync(string newMailboxName, bool subscribe = false) {}
     public virtual ImapOpenMailbox Open(bool asReadOnly = false) {}
     public virtual Task<ImapOpenMailbox> OpenAsync(bool asReadOnly = false) {}
-    internal protected ImapCommandResult ProcessResult(ImapCommandResult result) {}
-    internal protected virtual ImapCommandResult ProcessResult(ImapCommandResult result, Func<ImapTaggedStatusResponse, bool> throwIfErrorResponse) {}
+    internal protected virtual ImapCommandResult ProcessResult(ImapCommandResult result, Func<ImapTaggedStatusResponse, bool> throwIfErrorResponse = null) {}
     protected void ReRetrieveMailboxFlags() {}
     public void Refresh(bool reretrieveMailboxFlags = false) {}
     public Task RefreshAsync(bool reretrieveMailboxFlags = false) {}
     internal protected virtual void RefreshCore(bool reretrieveMailboxFlags) {}
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public string[] SplitMailboxHierarchy(string mailboxName) {}
     public void Subscribe(bool recursive = false) {}
     public Task SubscribeAsync(bool recursive = false) {}
     public override string ToString() {}
     public void Unsubscribe(bool recursive = false) {}
     public Task UnsubscribeAsync(bool recursive = false) {}
   }
 
   [Serializable]
   public class ImapMailboxNotFoundException : ImapException {
     protected ImapMailboxNotFoundException(SerializationInfo info, StreamingContext context) {}
     public ImapMailboxNotFoundException(string mailboxName) {}
     public ImapMailboxNotFoundException(string message, string mailboxName) {}
 
     public string Mailbox { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   public class ImapMailboxSizeChangedEventArgs : EventArgs {
     public ImapMailboxSizeChangedEventArgs(ImapOpenMailbox mailbox, long currentCount, long prevCount) {}
 
     public long CurrentCount { get; }
     public ImapOpenMailbox Mailbox { get; }
     public long PrevCount { get; }
   }
 
   public sealed class ImapMessage :
-    ImapMessageBase,
+    ImapMessageReference,
     IImapMessageDynamicAttributes,
     IImapMessageStaticAttributes,
     IImapUrl
   {
     public static readonly long ExpungedMessageSequenceNumber = 0;
 
+    public ImapMessageBody Body { get; }
     public DateTimeOffset DeliveredDate { get; }
     public ImapEnvelope Envelope { get; }
     public DateTimeOffset? EnvelopeDate { get; }
     public string EnvelopeSubject { get; }
     public IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
     public bool HasEncapsulatedMessage { get; }
+    public ImapMessageHeader Header { get; }
     [Obsolete("use DeliveredDate instead")]
     public DateTimeOffset InternalDate { get; }
     public bool IsAnswered { get; }
     public bool IsDeleted { get; }
     public bool IsDraft { get; }
     public bool IsFlagged { get; }
     public bool IsMarkedAsDeleted { get; }
     public bool IsMultiPart { get; }
     public bool IsRecent { get; }
     public bool IsSeen { get; }
     public long Length { get; }
     public MimeType MediaType { get; }
     public ImapMessagePart MessagePart { get; }
     public ulong ModSeq { get; }
     public long Sequence { get; }
     IReadOnlyCollection<string> IImapMessageStaticAttributes.BinarySizeSpecifiers { get; }
     IImapBodyStructure IImapMessageStaticAttributes.BodyStructure { get; }
     DateTimeOffset? IImapMessageStaticAttributes.InternalDate { get; }
     long IImapMessageStaticAttributes.Rfc822Size { get; }
     public long Uid { get; }
     public Uri Url { get; }
 
+    [Obsolete("use Body.Download() instead")]
     public Stream Download() {}
+    [Obsolete("use Body.Download() instead")]
     public Stream Download(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync() {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
-    public List<ImapMessagePart> FindAllMessageParts(MimeType mediaType) {}
-    public List<ImapMessagePart> FindAllMessageParts(Predicate<ImapMessagePart> match) {}
+    public IReadOnlyList<ImapMessagePart> FindAllMessageParts(MimeType mediaType) {}
+    public IReadOnlyList<ImapMessagePart> FindAllMessageParts(Predicate<ImapMessagePart> match) {}
     public ImapMessagePart FindMessagePart(MimeType mediaType) {}
     public ImapMessagePart FindMessagePart(Predicate<ImapMessagePart> match) {}
+    [Obsolete("use Header.ReadAsNameValuePairs() instead")]
     public IReadOnlyList<KeyValuePair<string, string>> GetHeader() {}
+    [Obsolete("use Header.ReadAsNameValuePairs() instead")]
     public IReadOnlyList<KeyValuePair<string, string>> GetHeader(IEnumerable<string> headerFields) {}
+    [Obsolete("use Header.ReadAsNameValuePairs() instead")]
     public IReadOnlyList<KeyValuePair<string, string>> GetHeader(bool decode, IEnumerable<string> headerFields) {}
+    [Obsolete("use Header.ReadAsNameValuePairs() instead")]
     public IReadOnlyList<KeyValuePair<string, string>> GetHeader(bool decode, params string[] headerFields) {}
+    [Obsolete("use Header.ReadAsNameValuePairs() instead")]
     public IReadOnlyList<KeyValuePair<string, string>> GetHeader(params string[] headerFields) {}
+    [Obsolete("use Header.ReadAsNameValuePairsAsync() instead")]
     public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync() {}
+    [Obsolete("use Header.ReadAsNameValuePairsAsync() instead")]
     public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(IEnumerable<string> headerFields) {}
+    [Obsolete("use Header.ReadAsNameValuePairsAsync() instead")]
     public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(bool decode, IEnumerable<string> headerFields) {}
+    [Obsolete("use Header.ReadAsNameValuePairsAsync() instead")]
     public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(bool decode, params string[] headerFields) {}
+    [Obsolete("use Header.ReadAsNameValuePairsAsync() instead")]
     public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(params string[] headerFields) {}
     public ImapMessagePart GetMessagePart(IEnumerable<int> partSpecifiers) {}
     public ImapMessagePart GetMessagePart(params int[] partSpecifiers) {}
     public ImapMessagePart GetMessagePart(string partSpecifier) {}
+    [Obsolete("use Header.ReadAsString() instead")]
     public string GetRawHeader() {}
+    [Obsolete("use Header.ReadAsString() instead")]
     public string GetRawHeader(IEnumerable<string> headerFields) {}
+    [Obsolete("use Header.ReadAsString() instead")]
     public string GetRawHeader(params string[] headerFields) {}
+    [Obsolete("use Header.ReadAsStringAsync() instead")]
     public Task<string> GetRawHeaderAsync() {}
+    [Obsolete("use Header.ReadAsStringAsync() instead")]
     public Task<string> GetRawHeaderAsync(IEnumerable<string> headerFields) {}
+    [Obsolete("use Header.ReadAsStringAsync() instead")]
     public Task<string> GetRawHeaderAsync(params string[] headerFields) {}
-    protected override ImapSequenceSet GetSequenceOrUidSet() {}
+    protected override IImapNumberSet GetSequenceOrUidSet() {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead() {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapFetchRange? fetchRange) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapFetchRange? fetchRange, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync() {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.Read(Action<StreamReader>) or Body.ReadAsString() instead")]
     public StreamReader OpenText() {}
+    [Obsolete("use Body.Read(Action<StreamReader>) or Body.ReadAsString() instead")]
     public StreamReader OpenText(Encoding charset) {}
+    [Obsolete("use Body.Read(Action<StreamReader>) or Body.ReadAsString() instead")]
     public StreamReader OpenText(Encoding charset, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.Read(Action<StreamReader>) or Body.ReadAsString() instead")]
     public StreamReader OpenText(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync() {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(Encoding charset) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsByteArray() instead")]
     public byte[] ReadAllBytes() {}
+    [Obsolete("use Body.ReadAsByteArray() instead")]
     public byte[] ReadAllBytes(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync() {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public string[] ReadAllLines() {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public string[] ReadAllLines(Encoding charset) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public string[] ReadAllLines(Encoding charset, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public string[] ReadAllLines(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync() {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(Encoding charset) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsString() instead")]
     public string ReadAllText() {}
+    [Obsolete("use Body.ReadAsString() instead")]
     public string ReadAllText(Encoding charset) {}
+    [Obsolete("use Body.ReadAsString() instead")]
     public string ReadAllText(Encoding charset, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsString() instead")]
     public string ReadAllText(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync() {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(Encoding charset) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T, TResult>(ImapMessageFetchBodyOptions options, Func<Stream, T, TResult> read, T arg) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T1, T2, T3, T4, TResult>(Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T1, T2, T3, T4, TResult>(ImapMessageFetchBodyOptions options, Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T1, T2, T3, TResult>(Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T1, T2, T3, TResult>(ImapMessageFetchBodyOptions options, Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T1, T2, TResult>(Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<T1, T2, TResult>(ImapMessageFetchBodyOptions options, Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(Encoding charset, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public IEnumerable<string> ReadLines() {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public IEnumerable<string> ReadLines(Encoding charset) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public IEnumerable<string> ReadLines(Encoding charset, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public IEnumerable<string> ReadLines(ImapMessageFetchBodyOptions options) {}
     public void Refresh() {}
     public Task RefreshAsync() {}
+    [Obsolete("use Body.Save() instead")]
     public void Save(string path) {}
+    [Obsolete("use Body.Save() instead")]
     public void Save(string path, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
     long IImapMessageStaticAttributes.GetBinarySizeOf(string section) {}
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
     public void ToggleFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
     public void ToggleFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public Task ToggleFlagsAsync(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
     public Task ToggleFlagsAsync(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public void ToggleKeywords(string keyword, params string[] keywords) {}
     public Task ToggleKeywordsAsync(string keyword, params string[] keywords) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(BinaryWriter writer) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(Stream stream) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(Stream stream, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
   }
 
-  public abstract class ImapMessageBase {
-    protected ImapMessageBase(ImapOpenMailbox mailbox) {}
+  public sealed class ImapMessageBody : ImapMessageBodyBase {
+    public Stream Download(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public void Read(Action<Stream> read, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public void Read(Action<StreamReader> read, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public TResult ReadAs<TArg, TResult>(Func<Stream, Encoding, TArg, TResult> converter, TArg arg, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public TResult ReadAs<TArg, TResult>(Func<Stream, TArg, TResult> converter, TArg arg, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public TResult ReadAs<TArg, TResult>(Func<StreamReader, TArg, TResult> converter, TArg arg, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public TResult ReadAs<TResult>(Converter<Stream, TResult> converter, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<TResult> ReadAsAsync<TArg, TResult>(Func<Stream, TArg, Task<TResult>> converter, TArg arg, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<TResult> ReadAsAsync<TArg, TResult>(Func<StreamReader, TArg, Task<TResult>> converter, TArg arg, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<TResult> ReadAsAsync<TResult, TArg>(Func<Stream, Encoding, TArg, Task<TResult>> converter, TArg arg, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, Task<TResult>> converter, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, Task<TResult>> converter, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public byte[] ReadAsByteArray(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<byte[]> ReadAsByteArrayAsync(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public string ReadAsString(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<string> ReadAsStringAsync(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public IReadOnlyList<string> ReadAsStringLines(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task<IReadOnlyList<string>> ReadAsStringLinesAsync(ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task ReadAsync(Func<Stream, Task> read, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task ReadAsync(Func<StreamReader, Task> read, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, EncodingSelectionCallback selectFallbackCharset = null, Encoding forceCharsetTo = null, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public void Save(string path, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task SaveAsync(string path, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public override string ToString() {}
+    public void WriteTo(BinaryWriter writer, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public void WriteTo(Stream stream, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+    public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options = ImapMessageFetchBodyOptions.Default, ImapFetchRange fetchRange = default, CancellationToken cancellationToken = default, IProgress<ImapMessageFetchProgressInfo> progress = null) {}
+  }
 
-    public ImapClient Client { get; }
-    public bool IsAvailable { get; }
-    public ImapOpenMailbox Mailbox { get; }
-    public long UidValidity { get; protected set; }
+  public abstract class ImapMessageBodyBase {
+    public static readonly Encoding DefaultCharset; // = "System.Text.Latin1Encoding"
 
-    public void AddFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
-    public void AddFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
-    public Task AddFlagsAsync(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
-    public Task AddFlagsAsync(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
-    public void AddKeywords(string keyword, params string[] keywords) {}
-    public Task AddKeywordsAsync(string keyword, params string[] keywords) {}
-    protected void CheckAttachedToSelectedMailbox() {}
-    protected void CheckMessageNumberAvailable(ImapSequenceSet sequenceOrUidSet) {}
-    public ImapMailbox CopyTo(string destinationMailboxName, bool tryCreate) {}
-    public void CopyTo(ImapMailbox destinationMailbox) {}
-    public void CopyTo(string destinationMailboxName) {}
-    public Task CopyToAsync(ImapMailbox destinationMailbox) {}
-    public Task CopyToAsync(string destinationMailboxName) {}
-    public Task<ImapMailbox> CopyToAsync(string destinationMailboxName, bool tryCreate) {}
-    public void Delete() {}
-    public Task DeleteAsync() {}
-    protected abstract ImapSequenceSet GetSequenceOrUidSet();
-    public void MarkAsDeleted() {}
-    public Task MarkAsDeletedAsync() {}
-    public void MarkAsSeen() {}
-    public Task MarkAsSeenAsync() {}
-    public ImapMailbox MoveTo(string destinationMailboxName, bool tryCreate) {}
-    public void MoveTo(ImapMailbox destinationMailbox) {}
-    public void MoveTo(string destinationMailboxName) {}
-    public Task MoveToAsync(ImapMailbox destinationMailbox) {}
-    public Task MoveToAsync(string destinationMailboxName) {}
-    public Task<ImapMailbox> MoveToAsync(string destinationMailboxName, bool tryCreate) {}
-    public void RemoveFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
-    public void RemoveFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
-    public Task RemoveFlagsAsync(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
-    public Task RemoveFlagsAsync(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
-    public void RemoveKeywords(string keyword, params string[] keywords) {}
-    public Task RemoveKeywordsAsync(string keyword, params string[] keywords) {}
-    public void SetFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
-    public void SetFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
-    public Task SetFlagsAsync(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
-    public Task SetFlagsAsync(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
-    public void SetKeywords(string keyword, params string[] keywords) {}
-    public Task SetKeywordsAsync(string keyword, params string[] keywords) {}
-    public void Store(ImapStoreDataItems storeDataItems) {}
-    public Task StoreAsync(ImapStoreDataItems storeDataItems) {}
-    protected void StoreCore(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems) {}
+    public bool IsOfEncapsulatedMessagePart { get; }
+    public bool IsOfTopLevel { get; }
+    public ImapMessage Message { get; }
+    public ImapMessagePart MessagePart { get; }
+    public string PartSpecifier { get; }
+  }
+
+  public sealed class ImapMessageHeader : ImapMessageBodyBase {
+    public Stream Download(IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public Task<Stream> DownloadAsync(IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public TResult ReadAs<TArg, TResult>(Func<Stream, TArg, TResult> converter, TArg arg, IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public TResult ReadAs<TResult>(Converter<Stream, TResult> converter, IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public Task<TResult> ReadAsAsync<TArg, TResult>(Func<Stream, TArg, Task<TResult>> converter, TArg arg, IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, Task<TResult>> converter, IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public IReadOnlyList<KeyValuePair<string, string>> ReadAsNameValuePairs(IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, bool decodeHeaderFieldValues = false, EncodingSelectionCallback selectFallbackCharset = null, CancellationToken cancellationToken = default) {}
+    public Task<IReadOnlyList<KeyValuePair<string, string>>> ReadAsNameValuePairsAsync(IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, bool decodeHeaderFieldValues = false, EncodingSelectionCallback selectFallbackCharset = null, CancellationToken cancellationToken = default) {}
+    public string ReadAsString(IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public Task<string> ReadAsStringAsync(IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public override string ToString() {}
+    public void WriteTo(Stream stream, IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
+    public Task WriteToAsync(Stream stream, IEnumerable<string> headerFields = null, bool excludePassedHeaderFields = false, CancellationToken cancellationToken = default) {}
   }
 
   [Serializable]
   public class ImapMessageNotFoundException : ImapException {
     protected ImapMessageNotFoundException(SerializationInfo info, StreamingContext context) {}
-    public ImapMessageNotFoundException(ImapSequenceSet sequenceOrUidSet) {}
-    public ImapMessageNotFoundException(string message, ImapSequenceSet sequenceOrUidSet) {}
+    public ImapMessageNotFoundException(IImapNumberSet sequenceOrUidSet) {}
+    public ImapMessageNotFoundException(string message, IImapNumberSet sequenceOrUidSet) {}
 
-    public ImapSequenceSet SequenceOrUidSet { get; }
+    public IImapNumberSet SequenceOrUidSet { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   public sealed class ImapMessagePart : IImapUrl {
     public static class Predicates {
       public static bool HasEncapsulatedMessagePart(ImapMessagePart part) {}
       public static bool IsAttachmentPart(ImapMessagePart part) {}
       public static bool IsEncapsulatedMessagePart(ImapMessagePart part) {}
       public static bool IsImagePart(ImapMessagePart part) {}
       public static bool IsInlinePart(ImapMessagePart part) {}
       public static bool IsMultiPart(ImapMessagePart part) {}
       public static bool IsPlainTextPart(ImapMessagePart part) {}
       public static bool IsTextPart(ImapMessagePart part) {}
       public static bool SeemsToBeAttachmentPart(ImapMessagePart part) {}
     }
 
+    public ImapMessageBody Body { get; }
     public ImapClient Client { get; }
     public string ContentDescription { get; }
     public string ContentDisposition { get; }
     public IReadOnlyDictionary<string, string> ContentDispositionParameters { get; }
     public string ContentID { get; }
     public IReadOnlyList<string> ContentLanguages { get; }
     public Uri ContentLocation { get; }
     public string ContentMD5 { get; }
     public string ContentTransferEncoding { get; }
     public ContentTransferEncodingMethod ContentTransferEncodingMethod { get; }
     public MimeType ContentType { get; }
     public string ContentTypeCharset { get; }
     public IReadOnlyDictionary<string, string> ContentTypeParameters { get; }
     public ImapEnvelope EncapsulatedMessageEnvelope { get; }
     public ImapMessagePart EncapsulatedMessagePart { get; }
     public bool HasEncapsulatedMessage { get; }
+    public ImapMessageHeader Header { get; }
     public bool IsDispositionAttachment { get; }
     public bool IsDispositionInline { get; }
     public bool IsEncapsulatedMessagePart { get; }
     public bool IsMultiPart { get; }
     public bool IsRootPart { get; }
     public long Length { get; }
     public long LineCount { get; }
     public ImapMessage Message { get; }
     public int NestLevel { get; }
     public IReadOnlyList<ImapMessagePart> NestedMessageParts { get; }
     public ImapMessagePart ParentPart { get; }
     public string Specifier { get; }
     public Uri Url { get; }
 
+    [Obsolete("use Body.Download() instead")]
     public Stream Download() {}
+    [Obsolete("use Body.Download() instead")]
     public Stream Download(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync() {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.DownloadAsync() instead")]
     public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
     public ImapMessagePart Find(Predicate<ImapMessagePart> match) {}
-    public List<ImapMessagePart> FindAll(Predicate<ImapMessagePart> match) {}
-    public List<ImapMessagePart> Flatten() {}
-    public List<ImapMessagePart> Flatten(bool containItself) {}
+    public IReadOnlyList<ImapMessagePart> FindAll(Predicate<ImapMessagePart> match) {}
+    public IReadOnlyList<ImapMessagePart> Flatten(bool containItself = false) {}
     public string GetContentFileName() {}
     public string GetContentFileName(EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
+    [Obsolete("use Header.ReadAsNameValuePairs() instead")]
     public IReadOnlyList<KeyValuePair<string, string>> GetHeader() {}
+    [Obsolete("use Header.ReadAsNameValuePairs() instead")]
     public IReadOnlyList<KeyValuePair<string, string>> GetHeader(bool decode) {}
+    [Obsolete("use Header.ReadAsNameValuePairsAsync() instead")]
     public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync() {}
+    [Obsolete("use Header.ReadAsNameValuePairsAsync() instead")]
     public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(bool decode) {}
+    [Obsolete("use Header.ReadAsString() instead")]
     public string GetRawHeader() {}
+    [Obsolete("use Header.ReadAsStringAsync() instead")]
     public Task<string> GetRawHeaderAsync() {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead() {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapFetchRange? fetchRange) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapFetchRange? fetchRange, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.Read(Action<Stream>) or Body.Download() instead")]
     public Stream OpenRead(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync() {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<Stream>) or Body.DownloadAsync() instead")]
     public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.Read(Action<StreamReader>) or Body.ReadAsString() instead")]
     public StreamReader OpenText() {}
+    [Obsolete("use Body.Read(Action<StreamReader>) or Body.ReadAsString() instead")]
     public StreamReader OpenText(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.Read(Action<StreamReader>) or Body.ReadAsString() instead")]
     public StreamReader OpenText(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync() {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsync(Action<StreamReader>) or Body.ReadAsStringAsync() instead")]
     public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsByteArray() instead")]
     public byte[] ReadAllBytes() {}
+    [Obsolete("use Body.ReadAsByteArray() instead")]
     public byte[] ReadAllBytes(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync() {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsByteArrayAsync() instead")]
     public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public string[] ReadAllLines() {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public string[] ReadAllLines(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public string[] ReadAllLines(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync() {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsStringLinesAsync() instead")]
     public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsString() instead")]
     public string ReadAllText() {}
+    [Obsolete("use Body.ReadAsString() instead")]
     public string ReadAllText(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsString() instead")]
     public string ReadAllText(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync() {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsStringAsync() instead")]
     public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAs() instead")]
     public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsAsync() instead")]
     public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public IEnumerable<string> ReadLines() {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public IEnumerable<string> ReadLines(ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.ReadAsStringLines() instead")]
     public IEnumerable<string> ReadLines(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
+    [Obsolete("use Body.Save() instead")]
     public void Save(string path) {}
+    [Obsolete("use Body.Save() instead")]
     public void Save(string path, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.SaveAsync() instead")]
     public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
     public void Traverse(Action<ImapMessagePart> visitInToPart, Action<ImapMessagePart> visitOutFromPart) {}
     public void Traverse(Action<ImapMessagePart> visitPart) {}
     public void Traverse(bool visitItself, Action<ImapMessagePart> visitInToPart, Action<ImapMessagePart> visitOutFromPart) {}
     public void Traverse(bool visitItself, Action<ImapMessagePart> visitPart) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(BinaryWriter writer) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(Stream stream) {}
+    [Obsolete("use Body.WriteTo() instead")]
     public void WriteTo(Stream stream, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
+    [Obsolete("use Body.WriteToAsync() instead")]
     public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
   }
 
   public abstract class ImapMessageQuery :
-    ImapMessageBase,
+    ImapMessageReference,
     IEnumerable<ImapMessage>
   {
     protected ImapMessageQuery(ImapOpenMailbox mailbox, ImapMessageFetchAttributeOptions fetchOptions, bool orderBySequenceNumber) {}
 
     public IEnumerator<ImapMessage> GetEnumerator() {}
     IEnumerator IEnumerable.GetEnumerator() {}
     public ImapMessage[] ToArray() {}
     public Task<ImapMessage[]> ToArrayAsync(CancellationToken cancellationToken = default) {}
     public List<ImapMessage> ToList() {}
     public Task<List<ImapMessage>> ToListAsync(CancellationToken cancellationToken = default) {}
     public override string ToString() {}
   }
 
+  public abstract class ImapMessageReference {
+    protected ImapMessageReference(ImapOpenMailbox mailbox) {}
+
+    public ImapClient Client { get; }
+    public bool IsAvailable { get; }
+    public ImapOpenMailbox Mailbox { get; }
+    public long UidValidity { get; protected set; }
+
+    public void AddFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
+    public void AddFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
+    public Task AddFlagsAsync(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
+    public Task AddFlagsAsync(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
+    public void AddKeywords(string keyword, params string[] keywords) {}
+    public Task AddKeywordsAsync(string keyword, params string[] keywords) {}
+    public ImapMailbox CopyTo(string destinationMailboxName, bool tryCreate) {}
+    public void CopyTo(ImapMailbox destinationMailbox) {}
+    public void CopyTo(string destinationMailboxName) {}
+    public Task CopyToAsync(ImapMailbox destinationMailbox) {}
+    public Task CopyToAsync(string destinationMailboxName) {}
+    public Task<ImapMailbox> CopyToAsync(string destinationMailboxName, bool tryCreate) {}
+    public void Delete() {}
+    public Task DeleteAsync() {}
+    protected abstract IImapNumberSet GetSequenceOrUidSet();
+    public void MarkAsDeleted() {}
+    public Task MarkAsDeletedAsync() {}
+    public void MarkAsSeen() {}
+    public Task MarkAsSeenAsync() {}
+    public ImapMailbox MoveTo(string destinationMailboxName, bool tryCreate) {}
+    public void MoveTo(ImapMailbox destinationMailbox) {}
+    public void MoveTo(string destinationMailboxName) {}
+    public Task MoveToAsync(ImapMailbox destinationMailbox) {}
+    public Task MoveToAsync(string destinationMailboxName) {}
+    public Task<ImapMailbox> MoveToAsync(string destinationMailboxName, bool tryCreate) {}
+    public void RemoveFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
+    public void RemoveFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
+    public Task RemoveFlagsAsync(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
+    public Task RemoveFlagsAsync(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
+    public void RemoveKeywords(string keyword, params string[] keywords) {}
+    public Task RemoveKeywordsAsync(string keyword, params string[] keywords) {}
+    public void SetFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
+    public void SetFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
+    public Task SetFlagsAsync(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
+    public Task SetFlagsAsync(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
+    public void SetKeywords(string keyword, params string[] keywords) {}
+    public Task SetKeywordsAsync(string keyword, params string[] keywords) {}
+    public void Store(ImapStoreDataItems storeDataItems) {}
+    public Task StoreAsync(ImapStoreDataItems storeDataItems) {}
+    protected void StoreCore(ImapStoreDataItems storeDataItems, IImapNumberSet specificSequenceOrUidSet = null) {}
+    protected void ThrowIfNotAttachedToSelectedMailbox() {}
+    internal protected void ThrowIfSequenceOrUidSetIsNotAvailable(out IImapNumberSet sequenceOrUidSet) {}
+  }
+
   public class ImapMessageStatusChangedEventArgs : EventArgs {
     public ImapMessageStatusChangedEventArgs(IReadOnlyList<ImapMessage> messages) {}
 
     public IReadOnlyList<ImapMessage> Messages { get; }
   }
 
   public class ImapMessageThread {
     public IReadOnlyList<ImapMessageThread> Children { get; }
     public int Depth { get; }
     public bool IsRoot { get; }
     public ImapMessage Message { get; }
     public ImapMessageThread Parent { get; }
 
     public void Traverse(Action<ImapMessageThread> visitInToThread, Action<ImapMessageThread> visitOutFromThread) {}
     public void Traverse(Action<ImapMessageThread> visitThread) {}
   }
 
   [Serializable]
   public class ImapMessageVanishedException : ImapInvalidOperationException {
     protected ImapMessageVanishedException(SerializationInfo info, StreamingContext context) {}
     public ImapMessageVanishedException(ImapMessage vanishedMessage) {}
     public ImapMessageVanishedException(string message, ImapMessage vanishedMessage) {}
 
     public ImapMessage VanishedMessage { get; }
   }
 
   public class ImapOpenMailbox :
     ImapMailbox,
     IDisposable
   {
     public class WatchMailboxContext {
       public ImapOpenMailbox Mailbox { get; }
 
       public bool Wait(int millisecondsTimeout = -1) {}
     }
 
     public IReadOnlyStringSet<ImapMessageFlag> ApplicableFlags { get; }
     public long FirstUnseenMessageNumber { get; }
     public bool IsAllowedToCreateKeywords { get; }
     public bool IsIdling { get; }
     public override bool IsOpen { get; }
     public bool IsReadOnly { get; }
     public bool IsUidPersistent { get; }
     public IReadOnlyStringSet<ImapMessageFlag> PermanentFlags { get; }
 
     public void Close() {}
     public Task CloseAsync() {}
     public void CopyMessagesTo(ImapMailbox destinationMailbox) {}
     public void CopyMessagesTo(ImapMailbox destinationMailbox, ImapSearchCriteria searchCriteria, Encoding encoding = null) {}
     public void CopyMessagesTo(ImapMailbox destinationMailbox, long uid, params long[] uids) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void CopyMessagesTo(ImapSearchCriteria searchCriteria, Encoding encoding, ImapMailbox destinationMailbox) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void CopyMessagesTo(ImapSearchCriteria searchCriteria, ImapMailbox destinationMailbox) {}
     public Task CopyMessagesToAsync(ImapMailbox destinationMailbox) {}
     public Task CopyMessagesToAsync(ImapMailbox destinationMailbox, ImapSearchCriteria searchCriteria, Encoding encoding = null) {}
     public Task CopyMessagesToAsync(ImapMailbox destinationMailbox, long uid, params long[] uids) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task CopyMessagesToAsync(ImapSearchCriteria searchCriteria, Encoding encoding, ImapMailbox destinationMailbox) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task CopyMessagesToAsync(ImapSearchCriteria searchCriteria, ImapMailbox destinationMailbox) {}
     public void Expunge() {}
     public Task ExpungeAsync() {}
     public ImapMessage GetMessageBySequence(long sequence, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     public Task<ImapMessage> GetMessageBySequenceAsync(long sequence, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     public ImapMessage GetMessageByUid(long uid, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     public Task<ImapMessage> GetMessageByUidAsync(long uid, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     public ImapMessage GetMessageFirstUnseen(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     public Task<ImapMessage> GetMessageFirstUnseenAsync(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetMessages(IEnumerable<long> uids, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetMessages(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetMessages(ImapMessageFetchAttributeOptions options, long uid, params long[] uids) {}
-    public ImapMessageQuery GetMessages(ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
-    public ImapMessageQuery GetMessages(ImapSearchCriteria searchCriteria, ImapMessageFetchAttributeOptions options) {}
-    public ImapMessageQuery GetMessages(long uid, params long[] uids) {}
-    public ImapMessageQuery GetMessagesGmailSearch(string gmailSearchQuery, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetMessagesNew(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetMessagesRecent(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetMessagesUnseen(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
-    public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetMessages(IEnumerable<long> uids, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetMessages(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetMessages(ImapMessageFetchAttributeOptions options, long uid, params long[] uids) {}
+    public IReadOnlyList<ImapMessage> GetMessages(ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
+    public IReadOnlyList<ImapMessage> GetMessages(ImapSearchCriteria searchCriteria, ImapMessageFetchAttributeOptions options) {}
+    public IReadOnlyList<ImapMessage> GetMessages(long uid, params long[] uids) {}
+    public IReadOnlyList<ImapMessage> GetMessagesGmailSearch(string gmailSearchQuery, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetMessagesNew(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetMessagesRecent(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetMessagesUnseen(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetSortedMessages(ImapSortCriteria sortOrder, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public IReadOnlyList<ImapMessage> GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
-    public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, ImapMessageFetchAttributeOptions options) {}
+    public IReadOnlyList<ImapMessage> GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, ImapMessageFetchAttributeOptions options) {}
     public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, ImapMessageFetchAttributeOptions options) {}
     public Task<ImapMessageThread> GetThreadedMessagesAsync(ImapThreadingAlgorithm threadingAlgorithm, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     public Task<ImapMessageThread> GetThreadedMessagesAsync(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<ImapMessageThread> GetThreadedMessagesAsync(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, ImapMessageFetchAttributeOptions options) {}
     public void Idle(TimeSpan timeout) {}
     public void Idle(TimeSpan timeout, TimeSpan pollingInterval) {}
     public void Idle(int millisecondsTimeout, int millisecondsPollingInterval = 600000) {}
     public void MoveMessagesTo(ImapMailbox destinationMailbox) {}
     public void MoveMessagesTo(ImapMailbox destinationMailbox, ImapSearchCriteria searchCriteria, Encoding encoding = null) {}
     public void MoveMessagesTo(ImapMailbox destinationMailbox, long uid, params long[] uids) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void MoveMessagesTo(ImapSearchCriteria searchCriteria, Encoding encoding, ImapMailbox destinationMailbox) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public void MoveMessagesTo(ImapSearchCriteria searchCriteria, ImapMailbox destinationMailbox) {}
     public Task MoveMessagesToAsync(ImapMailbox destinationMailbox) {}
     public Task MoveMessagesToAsync(ImapMailbox destinationMailbox, ImapSearchCriteria searchCriteria, Encoding encoding = null) {}
     public Task MoveMessagesToAsync(ImapMailbox destinationMailbox, long uid, params long[] uids) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task MoveMessagesToAsync(ImapSearchCriteria searchCriteria, Encoding encoding, ImapMailbox destinationMailbox) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task MoveMessagesToAsync(ImapSearchCriteria searchCriteria, ImapMailbox destinationMailbox) {}
     public override ImapOpenMailbox Open(bool asReadOnly = false) {}
     public override Task<ImapOpenMailbox> OpenAsync(bool asReadOnly = false) {}
-    internal protected override ImapCommandResult ProcessResult(ImapCommandResult result, Func<ImapTaggedStatusResponse, bool> throwIfErrorResponse) {}
+    internal protected override ImapCommandResult ProcessResult(ImapCommandResult result, Func<ImapTaggedStatusResponse, bool> throwIfErrorResponse = null) {}
+    public ImapMessageQuery QueryMessages(IEnumerable<long> uids, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QueryMessages(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QueryMessages(ImapMessageFetchAttributeOptions options, long uid, params long[] uids) {}
+    public ImapMessageQuery QueryMessages(ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QueryMessages(long uid, params long[] uids) {}
+    public ImapMessageQuery QueryMessagesGmailSearch(string gmailSearchQuery, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QueryMessagesNew(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QueryMessagesRecent(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QueryMessagesUnseen(ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QuerySortedMessages(ImapSortCriteria sortOrder, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
+    public ImapMessageQuery QuerySortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, Encoding encoding = null, ImapMessageFetchAttributeOptions options = ImapMessageFetchAttributeOptions.Default) {}
     internal protected override void RefreshCore(bool reretrieveMailboxFlags) {}
     public ImapOpenMailbox.WatchMailboxContext StartIdle(TimeSpan pollingInterval) {}
     public ImapOpenMailbox.WatchMailboxContext StartIdle(int millisecondsPollingInterval = 600000) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapOpenMailbox.WatchMailboxContext StartWaitForMessageArrival(ImapMessageFetchAttributeOptions fetchAttributeOptions, TimeSpan pollingInterval) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapOpenMailbox.WatchMailboxContext StartWaitForMessageArrival(ImapMessageFetchAttributeOptions fetchAttributeOptions, int millisecondsPollingInterval) {}
     public ImapOpenMailbox.WatchMailboxContext StartWaitForMessageArrival(TimeSpan pollingInterval, ImapMessageFetchAttributeOptions fetchAttributeOptions = ImapMessageFetchAttributeOptions.Default) {}
     public ImapOpenMailbox.WatchMailboxContext StartWaitForMessageArrival(int millisecondsPollingInterval = 600000, ImapMessageFetchAttributeOptions fetchAttributeOptions = ImapMessageFetchAttributeOptions.Default) {}
     public void StopIdle() {}
     public ImapMessageQuery StopWaitForMessageArrival() {}
     void IDisposable.Dispose() {}
     public ImapMessageQuery WaitForMessageArrival(TimeSpan timeout, ImapMessageFetchAttributeOptions fetchAttributeOptions = ImapMessageFetchAttributeOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapMessageQuery WaitForMessageArrival(TimeSpan timeout, ImapMessageFetchAttributeOptions fetchAttributeOptions, TimeSpan pollingInterval) {}
     public ImapMessageQuery WaitForMessageArrival(TimeSpan timeout, TimeSpan pollingInterval, ImapMessageFetchAttributeOptions fetchAttributeOptions = ImapMessageFetchAttributeOptions.Default) {}
     [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public ImapMessageQuery WaitForMessageArrival(int millisecondsTimeout, ImapMessageFetchAttributeOptions fetchAttributeOptions, int millisecondsPollingInterval) {}
     public ImapMessageQuery WaitForMessageArrival(int millisecondsTimeout, int millisecondsPollingInterval = 600000, ImapMessageFetchAttributeOptions fetchAttributeOptions = ImapMessageFetchAttributeOptions.Default) {}
   }
 
   public static class ImapSslConnection {
     public static LocalCertificateSelectionCallback ClientCertificateSelectionCallback { get; set; }
     public static X509Certificate2Collection ClientCertificates { get; }
     public static RemoteCertificateValidationCallback DangerousAcceptAnyServerCertificateValidator { get; }
     public static SslProtocols EnabledSslProtocols { get; set; }
     public static RemoteCertificateValidationCallback ServerCertificateValidationCallback { get; set; }
   }
 
   [Serializable]
   public class ImapUnavailableException : ImapInvalidOperationException {
     protected ImapUnavailableException(SerializationInfo info, StreamingContext context) {}
     public ImapUnavailableException() {}
     public ImapUnavailableException(string message) {}
   }
 
-  public struct ImapMessageFetchProgressInfo {
+  public readonly struct ImapMessageFetchProgressInfo {
     public ImapMessageFetchProgressInfo(long fetchedOctetCount, long totalOctetCount, CancellationToken cancellationToken) {}
 
     public CancellationToken CancellationToken { get; }
     public long FetchedOctetCount { get; }
     public int ProgressPercentage { get; }
     public long TotalOctetCount { get; }
 
     public override string ToString() {}
   }
 }
 
 namespace Smdn.Net.Imap4.Protocol {
   public enum ImapFetchDataItemMacro : int {
     All = 0,
     Extensible = 3,
     Fast = 1,
     Full = 2,
   }
 
   [Serializable]
   public class ImapAuthenticationException : ImapErrorResponseException {
     protected ImapAuthenticationException(SerializationInfo info, StreamingContext context) {}
     public ImapAuthenticationException() {}
     public ImapAuthenticationException(ImapCommandResult result) {}
   }
 
   [Serializable]
   public sealed class ImapAuthenticationMechanism :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapAuthenticationMechanism>
   {
     public static readonly ImapAuthenticationMechanism Anonymous; // = "ANONYMOUS"
     public static readonly ImapAuthenticationMechanism CRAMMD5; // = "CRAM-MD5"
     public static readonly ImapAuthenticationMechanism DigestMD5; // = "DIGEST-MD5"
     public static readonly ImapAuthenticationMechanism External; // = "EXTERNAL"
     public static readonly ImapAuthenticationMechanism Gssapi; // = "GSSAPI"
     public static readonly ImapAuthenticationMechanism IsoIec9798_M_DSA_SHA1; // = "9798-M-DSA-SHA1"
     public static readonly ImapAuthenticationMechanism IsoIec9798_M_ECDSA_SHA1; // = "9798-M-ECDSA-SHA1"
     public static readonly ImapAuthenticationMechanism IsoIec9798_M_RSA_SHA1_ENC; // = "9798-M-RSA-SHA1-ENC"
     public static readonly ImapAuthenticationMechanism IsoIec9798_U_DSA_SHA1; // = "9798-U-DSA-SHA1"
     public static readonly ImapAuthenticationMechanism IsoIec9798_U_ECDSA_SHA1; // = "9798-U-ECDSA-SHA1"
     public static readonly ImapAuthenticationMechanism IsoIec9798_U_RSA_SHA1_ENC; // = "9798-U-RSA-SHA1-ENC"
     public static readonly ImapAuthenticationMechanism KerberosV4; // = "KERBEROS_V4"
     public static readonly ImapAuthenticationMechanism KerberosV5; // = "KERBEROS_V5"
     public static readonly ImapAuthenticationMechanism Login; // = "LOGIN"
     public static readonly ImapAuthenticationMechanism NTLM; // = "NTLM"
     public static readonly ImapAuthenticationMechanism OTP; // = "OTP"
     public static readonly ImapAuthenticationMechanism Plain; // = "PLAIN"
     public static readonly ImapAuthenticationMechanism SKey; // = "SKEY"
     public static readonly ImapAuthenticationMechanism SecureID; // = "SECURID"
     public static readonly ImapAuthenticationMechanism SelectAppropriate; // = "*"
 
     public ImapAuthenticationMechanism(string mechanismName, ImapCapability requiredCapability = null) {}
 
     public static IReadOnlyStringSet<ImapAuthenticationMechanism> AllMechanisms { get; }
     public IEnumerable<ImapCapability> RequiredCapabilities { get; }
 
     public bool Equals(ImapAuthenticationMechanism other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapAuthenticationMechanism x, ImapAuthenticationMechanism y) {}
     public static bool operator != (ImapAuthenticationMechanism x, ImapAuthenticationMechanism y) {}
   }
 
   [Serializable]
   public sealed class ImapCapability :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapCapability>
   {
     public static readonly ImapCapability Acl; // = "ACL"
     public static readonly ImapCapability AnnotateExperiment1; // = "ANNOTATE-EXPERIMENT-1"
     public static readonly ImapCapability Binary; // = "BINARY"
     public static readonly ImapCapability Catenate; // = "CATENATE"
     public static readonly ImapCapability Children; // = "CHILDREN"
     public static readonly ImapCapability CompressDeflate; // = "COMPRESS=DEFLATE"
     public static readonly ImapCapability CondStore; // = "CONDSTORE"
     public static readonly ImapCapability ContextSearch; // = "CONTEXT=SEARCH"
     public static readonly ImapCapability ContextSort; // = "CONTEXT=SORT"
     public static readonly ImapCapability Convert; // = "CONVERT"
     public static readonly ImapCapability CreateSpecialUse; // = "CREATE-SPECIAL-USE"
     public static readonly ImapCapability ESearch; // = "ESEARCH"
     public static readonly ImapCapability ESort; // = "ESORT"
     public static readonly ImapCapability Enable; // = "ENABLE"
     public static readonly ImapCapability Filters; // = "FILTERS"
     public static readonly ImapCapability GimapGmExt1; // = "X-GM-EXT-1"
     public static readonly ImapCapability GimapXlist; // = "XLIST"
     public static readonly ImapCapability GimapXyzzy; // = "XYZZY"
     public static readonly ImapCapability I18NLevel1; // = "I18NLEVEL=1"
     public static readonly ImapCapability I18NLevel2; // = "I18NLEVEL=2"
     public static readonly ImapCapability ID; // = "ID"
     public static readonly ImapCapability Idle; // = "IDLE"
     public static readonly ImapCapability Imap4; // = "IMAP4"
     public static readonly ImapCapability Imap4Rev1; // = "IMAP4rev1"
     public static readonly ImapCapability Language; // = "LANGUAGE"
     public static readonly ImapCapability ListExtended; // = "LIST-EXTENDED"
     public static readonly ImapCapability ListStatus; // = "LIST-STATUS"
     public static readonly ImapCapability LiteralNonSync; // = "LITERAL+"
     public static readonly ImapCapability LoginDisabled; // = "LOGINDISABLED"
     public static readonly ImapCapability LoginReferrals; // = "LOGIN-REFERRALS"
     public static readonly ImapCapability MailboxReferrals; // = "MAILBOX-REFERRALS"
     public static readonly ImapCapability Metadata; // = "METADATA"
     public static readonly ImapCapability MetadataServer; // = "METADATA-SERVER"
     public static readonly ImapCapability Move; // = "MOVE"
     public static readonly ImapCapability MultiAppend; // = "MULTIAPPEND"
     public static readonly ImapCapability Multisearch; // = "MULTISEARCH"
     public static readonly ImapCapability Namespace; // = "NAMESPACE"
     public static readonly ImapCapability NetscapeExtension; // = "X-NETSCAPE"
     public static readonly ImapCapability Notify; // = "NOTIFY"
     public static readonly ImapCapability QuickResync; // = "QRESYNC"
     public static readonly ImapCapability Quota; // = "QUOTA"
     public static readonly ImapCapability SaslIR; // = "SASL-IR"
     public static readonly ImapCapability SearchFuzzy; // = "SEARCH=FUZZY"
     public static readonly ImapCapability Searchres; // = "SEARCHRES"
     public static readonly ImapCapability Sort; // = "SORT"
     public static readonly ImapCapability SortDisplay; // = "SORT=DISPLAY"
     public static readonly ImapCapability SpecialUse; // = "SPECIAL-USE"
     public static readonly ImapCapability StartTls; // = "STARTTLS"
     public static readonly ImapCapability ThreadOrderedSubject; // = "THREAD=ORDEREDSUBJECT"
     public static readonly ImapCapability ThreadReferences; // = "THREAD=REFERENCES"
     public static readonly ImapCapability UTF8Accept; // = "UTF8=ACCEPT"
     public static readonly ImapCapability UTF8All; // = "UTF8=ALL"
     public static readonly ImapCapability UTF8Append; // = "UTF8=APPEND"
     public static readonly ImapCapability UTF8Only; // = "UTF8=ONLY"
     public static readonly ImapCapability UTF8User; // = "UTF8=USER"
     public static readonly ImapCapability UWImapdScan; // = "SCAN"
     public static readonly ImapCapability UidPlus; // = "UIDPLUS"
     public static readonly ImapCapability Unselect; // = "UNSELECT"
     public static readonly ImapCapability UrlAuth; // = "URLAUTH"
     public static readonly ImapCapability UrlAuthBinary; // = "URLAUTH=BINARY"
     public static readonly ImapCapability Within; // = "WITHIN"
 
     public ImapCapability(string val) {}
 
     public static IReadOnlyStringSet<ImapCapability> AllCapabilities { get; }
 
     public bool Equals(ImapCapability other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapCapability x, ImapCapability y) {}
     public static bool operator != (ImapCapability x, ImapCapability y) {}
   }
 
   public static class ImapCapabilitySetExtensions {
     public static bool IsCapable(this IReadOnlyStringSet<ImapCapability> capabilities, ImapDataItems feature) {}
-    public static bool IsCapable(this IReadOnlyStringSet<ImapCapability> capabilities, ImapStringEnum feature) {}
+    public static bool IsCapable(this IReadOnlyStringSet<ImapCapability> capabilities, ImapEnumValue feature) {}
   }
 
   [Serializable]
   public sealed class ImapCollationAlgorithm :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapCollationAlgorithm>
   {
     public static readonly ImapCollationAlgorithm AsciiCasemap; // = "i;ascii-casemap"
     public static readonly ImapCollationAlgorithm AsciiNumeric; // = "i;ascii-numeric"
     public static readonly ImapCollationAlgorithm Default; // = "default"
     public static readonly ImapCollationAlgorithm Octet; // = "i;octet"
     public static readonly ImapCollationAlgorithm UnicodeCasemap; // = "i;unicode-casemap"
 
     public ImapCollationAlgorithm(string collationAlgorithm) {}
 
     public static IReadOnlyStringSet<ImapCollationAlgorithm> AllAlgorithms { get; }
 
     public bool Equals(ImapCollationAlgorithm other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapCollationAlgorithm x, ImapCollationAlgorithm y) {}
     public static bool operator != (ImapCollationAlgorithm x, ImapCollationAlgorithm y) {}
   }
 
   public abstract class ImapCombinableDataItems : ImapDataItems {
   }
 
   [Serializable]
   public sealed class ImapCompressionMechanism :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapCompressionMechanism>
   {
     public static readonly ImapCompressionMechanism Deflate; // = "DEFLATE"
 
     public static IReadOnlyStringSet<ImapCompressionMechanism> AllMechanisms { get; }
 
     public bool Equals(ImapCompressionMechanism other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapCompressionMechanism x, ImapCompressionMechanism y) {}
     public static bool operator != (ImapCompressionMechanism x, ImapCompressionMechanism y) {}
   }
 
   [Serializable]
   public class ImapConnectionException : ImapException {
     protected ImapConnectionException(SerializationInfo info, StreamingContext context) {}
     public ImapConnectionException() {}
     public ImapConnectionException(string message) {}
     public ImapConnectionException(string message, Exception innerException) {}
   }
 
   public abstract class ImapDataItems : ImapString {
     public override int GetHashCode() {}
     public override string ToString() {}
   }
 
   public static class ImapDateTimeFormat {
     public static string ToDateString(DateTime date) {}
     public static string ToDateTimeString(DateTimeOffset dateTime) {}
     public static bool TryParse(string dateTime, out DateTimeOffset result) {}
   }
 
   public static class ImapDefaultPorts {
     public const int Imap = 143;
     public const int Imaps = 993;
   }
 
   [Serializable]
   public class ImapErrorResponseException : ImapInvalidOperationException {
     protected ImapErrorResponseException(SerializationInfo info, StreamingContext context) {}
     public ImapErrorResponseException() {}
     public ImapErrorResponseException(ImapCommandResult result) {}
     public ImapErrorResponseException(string message, ImapCommandResult result) {}
 
     public ImapCommandResult Result { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   public class ImapFetchDataItems : ImapCombinableDataItems {
     public static readonly ImapFetchDataItems All; // = "ALL"
     public static readonly ImapFetchDataItems Body; // = "(BODY)"
     public static readonly ImapFetchDataItems BodyStructure; // = "(BODYSTRUCTURE)"
     public static readonly ImapFetchDataItems Envelope; // = "(ENVELOPE)"
     public static readonly ImapFetchDataItems Fast; // = "FAST"
     public static readonly ImapFetchDataItems Flags; // = "(FLAGS)"
     public static readonly ImapFetchDataItems Full; // = "FULL"
     public static readonly ImapFetchDataItems InternalDate; // = "(INTERNALDATE)"
     public static readonly ImapFetchDataItems ModSeq; // = "(MODSEQ)"
     public static readonly ImapFetchDataItems Rfc822; // = "(RFC822)"
     public static readonly ImapFetchDataItems Rfc822Header; // = "(RFC822.HEADER)"
     public static readonly ImapFetchDataItems Rfc822Size; // = "(RFC822.SIZE)"
     public static readonly ImapFetchDataItems Rfc822Text; // = "(RFC822.TEXT)"
     public static readonly ImapFetchDataItems Uid; // = "(UID)"
 
     public static ImapFetchDataItems Binary(bool peek, string sectionBinary) {}
-    public static ImapFetchDataItems Binary(bool peek, string sectionBinary, ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems Binary(bool peek, string sectionBinary, ImapFetchRange range) {}
     public static ImapFetchDataItems Binary(bool peek, string sectionBinary, long partialStart, long partialLength) {}
     public static ImapFetchDataItems Binary(string sectionBinary) {}
-    public static ImapFetchDataItems Binary(string sectionBinary, ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems Binary(string sectionBinary, ImapFetchRange range) {}
     public static ImapFetchDataItems Binary(string sectionBinary, long partialStart, long partialLength) {}
     public static ImapFetchDataItems BinaryPeek(string sectionBinary) {}
-    public static ImapFetchDataItems BinaryPeek(string sectionBinary, ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems BinaryPeek(string sectionBinary, ImapFetchRange range) {}
     public static ImapFetchDataItems BinaryPeek(string sectionBinary, long partialStart, long partialLength) {}
     public static ImapFetchDataItems BinarySize(string sectionBinary) {}
     public static ImapFetchDataItems BodyPeek() {}
-    public static ImapFetchDataItems BodyPeek(ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems BodyPeek(ImapFetchRange range) {}
     public static ImapFetchDataItems BodyPeek(long partialStart, long partialLength) {}
     public static ImapFetchDataItems BodyPeek(string section) {}
-    public static ImapFetchDataItems BodyPeek(string section, ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems BodyPeek(string section, ImapFetchRange range) {}
     public static ImapFetchDataItems BodyPeek(string section, long partialStart, long partialLength) {}
     public static ImapFetchDataItems BodyText() {}
-    public static ImapFetchDataItems BodyText(ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems BodyText(ImapFetchRange range) {}
     public static ImapFetchDataItems BodyText(bool peek) {}
-    public static ImapFetchDataItems BodyText(bool peek, ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems BodyText(bool peek, ImapFetchRange range) {}
     public static ImapFetchDataItems BodyText(bool peek, long partialStart, long partialLength) {}
     public static ImapFetchDataItems BodyText(bool peek, string section) {}
-    public static ImapFetchDataItems BodyText(bool peek, string section, ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems BodyText(bool peek, string section, ImapFetchRange range) {}
     public static ImapFetchDataItems BodyText(bool peek, string section, long partialStart, long partialLength) {}
     public static ImapFetchDataItems BodyText(long partialStart, long partialLength) {}
     public static ImapFetchDataItems BodyText(string section) {}
-    public static ImapFetchDataItems BodyText(string section, ImapFetchRange? @partial) {}
+    public static ImapFetchDataItems BodyText(string section, ImapFetchRange range) {}
     public static ImapFetchDataItems BodyText(string section, long partialStart, long partialLength) {}
     public static ImapFetchDataItems Combine(ImapFetchDataItems x, ImapFetchDataItems y) {}
     public ImapFetchDataItems CombineWith(ImapFetchDataItems dataItem) {}
     public static ImapFetchDataItems FromMacro(ImapFetchDataItemMacro macro) {}
     public static ImapFetchDataItems FromUri(Uri uri) {}
     public static ImapFetchDataItems operator + (ImapFetchDataItems x, ImapFetchDataItems y) {}
   }
 
   public sealed class ImapGetMetadataOptions : ImapCombinableDataItems {
     public static readonly ImapGetMetadataOptions Depth0; // = "(DEPTH 0)"
     public static readonly ImapGetMetadataOptions Depth1; // = "(DEPTH 1)"
     public static readonly ImapGetMetadataOptions DepthInfinity; // = "(DEPTH infinity)"
 
     public static ImapGetMetadataOptions Combine(ImapGetMetadataOptions x, ImapGetMetadataOptions y) {}
     public ImapGetMetadataOptions CombineWith(ImapGetMetadataOptions other) {}
     public static ImapGetMetadataOptions MaxSize(long maxSize) {}
     public static ImapGetMetadataOptions operator + (ImapGetMetadataOptions x, ImapGetMetadataOptions y) {}
   }
 
   [Serializable]
   public class ImapIncapableException : ImapInvalidOperationException {
     protected ImapIncapableException(SerializationInfo info, StreamingContext context) {}
     public ImapIncapableException() {}
     public ImapIncapableException(IEnumerable<ImapCapability> requiredCapabilities) {}
     public ImapIncapableException(ImapCapability requiredCapability) {}
     public ImapIncapableException(string message) {}
     public ImapIncapableException(string message, IEnumerable<ImapCapability> requiredCapabilities) {}
     public ImapIncapableException(string message, ImapCapability requiredCapability) {}
 
     public IReadOnlyList<ImapCapability> RequiredCapabilities { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public abstract class ImapInvalidOperationException : ImapException {
     protected ImapInvalidOperationException() {}
     protected ImapInvalidOperationException(SerializationInfo info, StreamingContext context) {}
     protected ImapInvalidOperationException(string message) {}
     protected ImapInvalidOperationException(string message, Exception innerException) {}
   }
 
   public sealed class ImapListReturnOptions : ImapCombinableDataItems {
     public static readonly ImapListReturnOptions Children; // = "(CHILDREN)"
     public static readonly ImapListReturnOptions Empty; // = "()"
     public static readonly ImapListReturnOptions SpecialUse; // = "(SPECIAL-USE)"
     public static readonly ImapListReturnOptions Subscribed; // = "(SUBSCRIBED)"
 
     public static ImapListReturnOptions Combine(ImapListReturnOptions x, ImapListReturnOptions y) {}
     public ImapListReturnOptions CombineWith(ImapListReturnOptions other) {}
     public static ImapListReturnOptions StatusDataItems(ImapStatusDataItems statusDataItems) {}
     public static ImapListReturnOptions operator + (ImapListReturnOptions x, ImapListReturnOptions y) {}
   }
 
   public sealed class ImapListSelectionOptions : ImapCombinableDataItems {
     public static readonly ImapListSelectionOptions Empty; // = "()"
     public static readonly ImapListSelectionOptions RecursiveMatch; // = "(RECURSIVEMATCH)"
     public static readonly ImapListSelectionOptions Remote; // = "(REMOTE)"
     public static readonly ImapListSelectionOptions SpecialUse; // = "(SPECIAL-USE)"
     public static readonly ImapListSelectionOptions Subscribed; // = "(SUBSCRIBED)"
 
     public static ImapListSelectionOptions Combine(ImapListSelectionOptions x, ImapListSelectionOptions y) {}
     public ImapListSelectionOptions CombineWith(ImapListSelectionOptions other) {}
     public static ImapListSelectionOptions operator + (ImapListSelectionOptions x, ImapListSelectionOptions y) {}
   }
 
   [Serializable]
   public sealed class ImapMailboxFlag :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapMailboxFlag>
   {
     public static readonly ImapMailboxFlag All; // = "\All"
     public static readonly ImapMailboxFlag Archive; // = "\Archive"
     public static readonly ImapMailboxFlag Drafts; // = "\Drafts"
     public static readonly ImapMailboxFlag Flagged; // = "\Flagged"
     public static readonly ImapMailboxFlag HasChildren; // = "\HasChildren"
     public static readonly ImapMailboxFlag HasNoChildren; // = "\HasNoChildren"
     public static readonly ImapMailboxFlag Junk; // = "\Junk"
     public static readonly ImapMailboxFlag Marked; // = "\Marked"
     public static readonly ImapMailboxFlag NoInferiors; // = "\Noinferiors"
     public static readonly ImapMailboxFlag NoSelect; // = "\Noselect"
     public static readonly ImapMailboxFlag NonExistent; // = "\NonExistent"
     public static readonly ImapMailboxFlag Remote; // = "\Remote"
     public static readonly ImapMailboxFlag Sent; // = "\Sent"
     public static readonly ImapMailboxFlag Subscribed; // = "\Subscribed"
     public static readonly ImapMailboxFlag Trash; // = "\Trash"
     public static readonly ImapMailboxFlag Unmarked; // = "\Unmarked"
 
     public static IReadOnlyStringSet<ImapMailboxFlag> AllFlags { get; }
     public static IReadOnlyStringSet<ImapMailboxFlag> UseFlags { get; }
 
     public bool Equals(ImapMailboxFlag other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapMailboxFlag x, ImapMailboxFlag y) {}
     public static bool operator != (ImapMailboxFlag x, ImapMailboxFlag y) {}
   }
 
   public static class ImapMailboxNames {
     public static readonly IEqualityComparer<string> EqualityComparer; // = "Smdn.Net.Imap4.Protocol.ImapMailboxNames+MailboxNameEqualityComparer"
     public const string Inbox = "INBOX";
 
     public static bool IsInbox(string mailbox) {}
   }
 
   [Serializable]
   public sealed class ImapMessageFlag :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapMessageFlag>
   {
     public static readonly ImapMessageFlag AllowedCreateKeywords; // = "\*"
     public static readonly ImapMessageFlag Answered; // = "\Answered"
     public static readonly ImapMessageFlag Deleted; // = "\Deleted"
     public static readonly ImapMessageFlag Draft; // = "\Draft"
     public static readonly ImapMessageFlag Flagged; // = "\Flagged"
     public static readonly ImapMessageFlag Recent; // = "\Recent"
     public static readonly ImapMessageFlag Seen; // = "\Seen"
 
     public ImapMessageFlag(string keyword, ImapCapability requiredCapability = null) {}
 
     public static IReadOnlyStringSet<ImapMessageFlag> AllFlags { get; }
     public static IReadOnlyStringSet<ImapMessageFlag> FetchFlags { get; }
     public bool IsSystemFlag { get; }
     public static IReadOnlyStringSet<ImapMessageFlag> NonApplicableFlags { get; }
     public static IReadOnlyStringSet<ImapMessageFlag> PermittedFlags { get; }
 
     public bool Equals(ImapMessageFlag other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static string GetValidatedKeyword(string keyword) {}
     public static bool IsValidKeyword(string keyword) {}
     public static bool operator == (ImapMessageFlag x, ImapMessageFlag y) {}
     public static bool operator != (ImapMessageFlag x, ImapMessageFlag y) {}
   }
 
   [Serializable]
   public class ImapNoAppropriateAuthMechanismException : ImapException {
     protected ImapNoAppropriateAuthMechanismException(SerializationInfo info, StreamingContext context) {}
     public ImapNoAppropriateAuthMechanismException() {}
     public ImapNoAppropriateAuthMechanismException(string message) {}
     public ImapNoAppropriateAuthMechanismException(string message, Exception innerException) {}
   }
 
   [Serializable]
   public class ImapProtocolViolationException : ImapInvalidOperationException {
     protected ImapProtocolViolationException(SerializationInfo info, StreamingContext context) {}
     public ImapProtocolViolationException() {}
     public ImapProtocolViolationException(string message) {}
   }
 
   [Serializable]
   public sealed class ImapResponseCode :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapResponseCode>
   {
     public static readonly ImapResponseCode Alert; // = "ALERT"
     public static readonly ImapResponseCode AlreadyExists; // = "ALREADYEXISTS"
     public static readonly ImapResponseCode AppendUid; // = "APPENDUID"
     public static readonly ImapResponseCode AuthenticationFailed; // = "AUTHENTICATIONFAILED"
     public static readonly ImapResponseCode AuthorizationFailed; // = "AUTHORIZATIONFAILED"
     public static readonly ImapResponseCode BadCharset; // = "BADCHARSET"
     public static readonly ImapResponseCode BadComparator; // = "BADCOMPARATOR"
     public static readonly ImapResponseCode CanNot; // = "CANNOT"
     public static readonly ImapResponseCode Capability; // = "CAPABILITY"
     public static readonly ImapResponseCode ClientBug; // = "CLIENTBUG"
     public static readonly ImapResponseCode CompressionActive; // = "COMPRESSIONACTIVE"
     public static readonly ImapResponseCode ContactAdmin; // = "CONTACTADMIN"
     public static readonly ImapResponseCode CopyUid; // = "COPYUID"
     public static readonly ImapResponseCode Corruption; // = "CORRUPTION"
     public static readonly ImapResponseCode Expired; // = "EXPIRED"
     public static readonly ImapResponseCode ExpungeIssued; // = "EXPUNGEISSUED"
     public static readonly ImapResponseCode HighestModSeq; // = "HIGHESTMODSEQ"
     public static readonly ImapResponseCode InUse; // = "INUSE"
     public static readonly ImapResponseCode Limit; // = "LIMIT"
     public static readonly ImapResponseCode Metadata; // = "METADATA"
     public static readonly ImapResponseCode MetadataLongEntries; // = "METADATA LONGENTRIES"
     public static readonly ImapResponseCode MetadataMaxSize; // = "METADATA MAXSIZE"
     public static readonly ImapResponseCode MetadataNoPrivate; // = "METADATA NOPRIVATE"
     public static readonly ImapResponseCode MetadataTooMany; // = "METADATA TOOMANY"
     public static readonly ImapResponseCode Modified; // = "MODIFIED"
     public static readonly ImapResponseCode NoModSeq; // = "NOMODSEQ"
     public static readonly ImapResponseCode NoPerm; // = "NOPERM"
     public static readonly ImapResponseCode NonExistent; // = "NONEXISTENT"
     public static readonly ImapResponseCode NotSaved; // = "NOTSAVED"
     public static readonly ImapResponseCode OverQuota; // = "OVERQUOTA"
     public static readonly ImapResponseCode Parse; // = "PARSE"
     public static readonly ImapResponseCode PermanentFlags; // = "PERMANENTFLAGS"
     public static readonly ImapResponseCode PrivacyRequired; // = "PRIVACYREQUIRED"
     public static readonly ImapResponseCode ReadOnly; // = "READ-ONLY"
     public static readonly ImapResponseCode ReadWrite; // = "READ-WRITE"
     public static readonly ImapResponseCode Referral; // = "REFERRAL"
     public static readonly ImapResponseCode ServerBug; // = "SERVERBUG"
     public static readonly ImapResponseCode TryCreate; // = "TRYCREATE"
     public static readonly ImapResponseCode UidNext; // = "UIDNEXT"
     public static readonly ImapResponseCode UidNotSticky; // = "UIDNOTSTICKY"
     public static readonly ImapResponseCode UidValidity; // = "UIDVALIDITY"
     public static readonly ImapResponseCode Unavailable; // = "UNAVAILABLE"
     public static readonly ImapResponseCode UndefinedFilter; // = "UNDEFINED-FILTER"
     public static readonly ImapResponseCode UnknownCte; // = "UNKNOWN-CTE"
     public static readonly ImapResponseCode Unseen; // = "UNSEEN"
     public static readonly ImapResponseCode UseAttr; // = "USEATTR"
 
     public static IReadOnlyStringSet<ImapResponseCode> AllCodes { get; }
 
     public bool Equals(ImapResponseCode other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapResponseCode x, ImapResponseCode y) {}
     public static bool operator != (ImapResponseCode x, ImapResponseCode y) {}
   }
 
   public sealed class ImapSearchCriteria :
     ImapCombinableDataItems,
     IImapUrlSearchQuery
   {
     public static readonly ImapSearchCriteria All; // = "ALL"
     public static readonly ImapSearchCriteria Answered; // = "ANSWERED"
     public static readonly ImapSearchCriteria Deleted; // = "DELETED"
     public static readonly ImapSearchCriteria Draft; // = "DRAFT"
     public static readonly ImapSearchCriteria Flagged; // = "FLAGGED"
     public static readonly ImapSearchCriteria New; // = "NEW"
     public static readonly ImapSearchCriteria Old; // = "OLD"
     public static readonly ImapSearchCriteria Recent; // = "RECENT"
     public static readonly ImapSearchCriteria Seen; // = "SEEN"
     public static readonly ImapSearchCriteria Unanswered; // = "UNANSWERED"
     public static readonly ImapSearchCriteria Undeleted; // = "UNDELETED"
     public static readonly ImapSearchCriteria Undraft; // = "UNDRAFT"
     public static readonly ImapSearchCriteria Unflagged; // = "UNFLAGGED"
     public static readonly ImapSearchCriteria Unseen; // = "UNSEEN"
 
     public ImapSearchCriteria And(ImapSearchCriteria searchingCriteria) {}
     public static ImapSearchCriteria And(ImapSearchCriteria x, ImapSearchCriteria y) {}
     public static ImapSearchCriteria Bcc(string @value) {}
     public static ImapSearchCriteria Before(DateTime date) {}
     public static ImapSearchCriteria Body(string @value) {}
     public static ImapSearchCriteria Cc(string @value) {}
     public static ImapSearchCriteria Filter(string filterName) {}
     public static ImapSearchCriteria From(string @value) {}
     public static ImapSearchCriteria FromUri(Uri uri) {}
     public static ImapSearchCriteria FromUri(Uri uri, bool splitCharset, out bool containsLiteral, out string charset) {}
     public static ImapSearchCriteria Header(string fieldName, string @value) {}
     public static ImapSearchCriteria Keyword(ImapMessageFlag flag) {}
     public static ImapSearchCriteria Keyword(string keyword) {}
     public static ImapSearchCriteria Larger(long size) {}
     public static ImapSearchCriteria ModSeq(ulong modificationSequence) {}
     public static ImapSearchCriteria ModSeqAllEntry(ulong modificationSequence, ImapMessageFlag flag) {}
     public static ImapSearchCriteria ModSeqPrivateEntry(ulong modificationSequence, ImapMessageFlag flag) {}
     public static ImapSearchCriteria ModSeqSharedEntry(ulong modificationSequence, ImapMessageFlag flag) {}
     public ImapSearchCriteria Not() {}
     public static ImapSearchCriteria Not(ImapSearchCriteria c) {}
     public static ImapSearchCriteria Older(TimeSpan interval) {}
     public static ImapSearchCriteria Older(long intervalSeconds) {}
     public static ImapSearchCriteria On(DateTime date) {}
     public ImapSearchCriteria Or(ImapSearchCriteria searchingCriteria) {}
     public static ImapSearchCriteria Or(ImapSearchCriteria x, ImapSearchCriteria y) {}
     public static ImapSearchCriteria SentBefore(DateTime date) {}
     public static ImapSearchCriteria SentOn(DateTime date) {}
     public static ImapSearchCriteria SentSince(DateTime date) {}
-    public static ImapSearchCriteria SequenceOrUidSet(ImapSequenceSet sequenceOrUidSet) {}
-    public static ImapSearchCriteria SequenceSet(ImapSequenceSet sequenceSet) {}
+    public static ImapSearchCriteria SequenceOrUidSet(IImapNumberSet sequenceOrUidSet) {}
+    public static ImapSearchCriteria SequenceSet(IImapNumberSet sequenceSet) {}
     public static ImapSearchCriteria Since(DateTime date) {}
     public static ImapSearchCriteria Smaller(long size) {}
     byte[] IImapUrlSearchQuery.GetEncodedQuery(Encoding charset, out bool charsetSpecified) {}
     public static ImapSearchCriteria Subject(string @value) {}
     public static ImapSearchCriteria Text(string @value) {}
     public static ImapSearchCriteria To(string @value) {}
-    public static ImapSearchCriteria Uid(ImapSequenceSet uidSet) {}
+    public static ImapSearchCriteria Uid(IImapNumberSet uidSet) {}
     public static ImapSearchCriteria Unkeyword(ImapMessageFlag flag) {}
     public static ImapSearchCriteria Unkeyword(string keyword) {}
     public static ImapSearchCriteria XGMRaw(string query) {}
     public static ImapSearchCriteria Younger(TimeSpan interval) {}
     public static ImapSearchCriteria Younger(long intervalSeconds) {}
     public static ImapSearchCriteria operator & (ImapSearchCriteria x, ImapSearchCriteria y) {}
     public static ImapSearchCriteria operator | (ImapSearchCriteria x, ImapSearchCriteria y) {}
     public static ImapSearchCriteria operator ! (ImapSearchCriteria c) {}
   }
 
   public class ImapSearchResultOptions : ImapCombinableDataItems {
     public static readonly ImapSearchResultOptions All; // = "(ALL)"
     public static readonly ImapSearchResultOptions Count; // = "(COUNT)"
     public static readonly ImapSearchResultOptions Max; // = "(MAX)"
     public static readonly ImapSearchResultOptions Min; // = "(MIN)"
     public static readonly ImapSearchResultOptions Save; // = "(SAVE)"
 
     public static ImapSearchResultOptions Combine(ImapSearchResultOptions x, ImapSearchResultOptions y) {}
     public ImapSearchResultOptions CombineWith(ImapSearchResultOptions other) {}
     public static ImapSearchResultOptions operator + (ImapSearchResultOptions x, ImapSearchResultOptions y) {}
   }
 
   [Serializable]
   public class ImapSecureConnectionException : ImapUpgradeConnectionException {
     protected ImapSecureConnectionException(SerializationInfo info, StreamingContext context) {}
     public ImapSecureConnectionException() {}
     public ImapSecureConnectionException(string message) {}
     public ImapSecureConnectionException(string message, Exception innerException) {}
   }
 
   [Serializable]
   public sealed class ImapServerDataResponseType :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapServerDataResponseType>
   {
     public static readonly ImapServerDataResponseType Capability; // = "CAPABILITY"
     public static readonly ImapServerDataResponseType Comparator; // = "COMPARATOR"
     public static readonly ImapServerDataResponseType ESearch; // = "ESEARCH"
     public static readonly ImapServerDataResponseType Enabled; // = "ENABLED"
     public static readonly ImapServerDataResponseType Exists; // = "EXISTS"
     public static readonly ImapServerDataResponseType Expunge; // = "EXPUNGE"
     public static readonly ImapServerDataResponseType Fetch; // = "FETCH"
     public static readonly ImapServerDataResponseType Flags; // = "FLAGS"
     public static readonly ImapServerDataResponseType Id; // = "ID"
     public static readonly ImapServerDataResponseType InvalidOrUnknown; // = "[?]"
     public static readonly ImapServerDataResponseType Language; // = "LANGUAGE"
     public static readonly ImapServerDataResponseType List; // = "LIST"
     public static readonly ImapServerDataResponseType Lsub; // = "LSUB"
     public static readonly ImapServerDataResponseType Metadata; // = "METADATA"
     public static readonly ImapServerDataResponseType Namespace; // = "NAMESPACE"
     public static readonly ImapServerDataResponseType Quota; // = "QUOTA"
     public static readonly ImapServerDataResponseType QuotaRoot; // = "QUOTAROOT"
     public static readonly ImapServerDataResponseType Recent; // = "RECENT"
     public static readonly ImapServerDataResponseType Search; // = "SEARCH"
     public static readonly ImapServerDataResponseType Sort; // = "SORT"
     public static readonly ImapServerDataResponseType Status; // = "STATUS"
     public static readonly ImapServerDataResponseType Thread; // = "THREAD"
 
     public static IReadOnlyStringSet<ImapServerDataResponseType> AllTypes { get; }
 
     public bool Equals(ImapServerDataResponseType other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapServerDataResponseType x, ImapServerDataResponseType y) {}
     public static bool operator != (ImapServerDataResponseType x, ImapServerDataResponseType y) {}
   }
 
   public sealed class ImapSortCriteria : ImapCombinableDataItems {
     public static readonly ImapSortCriteria Arrival; // = "(ARRIVAL)"
     public static readonly ImapSortCriteria ArrivalReverse; // = "(REVERSE ARRIVAL)"
     public static readonly ImapSortCriteria Cc; // = "(CC)"
     public static readonly ImapSortCriteria CcReverse; // = "(REVERSE CC)"
     public static readonly ImapSortCriteria Date; // = "(DATE)"
     public static readonly ImapSortCriteria DateReverse; // = "(REVERSE DATE)"
     public static readonly ImapSortCriteria DisplayFrom; // = "(DISPLAYFROM)"
     public static readonly ImapSortCriteria DisplayTo; // = "(DISPLAYTO)"
     public static readonly ImapSortCriteria From; // = "(FROM)"
     public static readonly ImapSortCriteria FromReverse; // = "(REVERSE FROM)"
     public static readonly ImapSortCriteria Size; // = "(SIZE)"
     public static readonly ImapSortCriteria SizeReverse; // = "(REVERSE SIZE)"
     public static readonly ImapSortCriteria Subject; // = "(SUBJECT)"
     public static readonly ImapSortCriteria SubjectReverse; // = "(REVERSE SUBJECT)"
     public static readonly ImapSortCriteria To; // = "(TO)"
     public static readonly ImapSortCriteria ToReverse; // = "(REVERSE TO)"
 
     public static ImapSortCriteria Combine(ImapSortCriteria x, ImapSortCriteria y) {}
     public ImapSortCriteria CombineWith(ImapSortCriteria criteria) {}
     public static ImapSortCriteria operator + (ImapSortCriteria x, ImapSortCriteria y) {}
   }
 
   public sealed class ImapStatusDataItems : ImapCombinableDataItems {
     public static readonly ImapStatusDataItems HighestModSeq; // = "(HIGHESTMODSEQ)"
     public static readonly ImapStatusDataItems Messages; // = "(MESSAGES)"
     public static readonly ImapStatusDataItems Recent; // = "(RECENT)"
     public static readonly ImapStatusDataItems StandardAll; // = "(MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)"
     public static readonly ImapStatusDataItems UidNext; // = "(UIDNEXT)"
     public static readonly ImapStatusDataItems UidValidity; // = "(UIDVALIDITY)"
     public static readonly ImapStatusDataItems Unseen; // = "(UNSEEN)"
 
     public static ImapStatusDataItems Combine(ImapStatusDataItems x, ImapStatusDataItems y) {}
     public ImapStatusDataItems CombineWith(ImapStatusDataItems dataItem) {}
     public static ImapStatusDataItems operator + (ImapStatusDataItems x, ImapStatusDataItems y) {}
   }
 
   public sealed class ImapStoreDataItems : ImapDataItems {
     public ImapString ItemName { get; }
 
     public static ImapStoreDataItems AddFlags(IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems AddFlags(IEnumerable<string> keywords, IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems AddFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public static ImapStoreDataItems AddFlags(string keyword, params string[] keywords) {}
     public static ImapStoreDataItems AddFlagsSilent(IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems AddFlagsSilent(IEnumerable<string> keywords, IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems AddFlagsSilent(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public static ImapStoreDataItems AddFlagsSilent(string keyword, params string[] keywords) {}
     public static ImapStoreDataItems RemoveFlags(IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems RemoveFlags(IEnumerable<string> keywords, IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems RemoveFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public static ImapStoreDataItems RemoveFlags(string keyword, params string[] keywords) {}
     public static ImapStoreDataItems RemoveFlagsSilent(IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems RemoveFlagsSilent(IEnumerable<string> keywords, IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems RemoveFlagsSilent(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public static ImapStoreDataItems RemoveFlagsSilent(string keyword, params string[] keywords) {}
     public static ImapStoreDataItems ReplaceFlags(IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems ReplaceFlags(IEnumerable<string> keywords, IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems ReplaceFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public static ImapStoreDataItems ReplaceFlags(string keyword, params string[] keywords) {}
     public static ImapStoreDataItems ReplaceFlagsSilent(IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems ReplaceFlagsSilent(IEnumerable<string> keywords, IEnumerable<ImapMessageFlag> flags) {}
     public static ImapStoreDataItems ReplaceFlagsSilent(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
     public static ImapStoreDataItems ReplaceFlagsSilent(string keyword, params string[] keywords) {}
     public override string ToString() {}
   }
 
   [Serializable]
   public sealed class ImapThreadingAlgorithm :
-    ImapStringEnum,
+    ImapEnumValue,
     IEquatable<ImapThreadingAlgorithm>
   {
     public static readonly ImapThreadingAlgorithm OrderedSubject; // = "ORDEREDSUBJECT"
     public static readonly ImapThreadingAlgorithm References; // = "REFERENCES"
 
     public static IReadOnlyStringSet<ImapThreadingAlgorithm> AllAlgorithms { get; }
 
     public bool Equals(ImapThreadingAlgorithm other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public static bool operator == (ImapThreadingAlgorithm x, ImapThreadingAlgorithm y) {}
     public static bool operator != (ImapThreadingAlgorithm x, ImapThreadingAlgorithm y) {}
   }
 
   [Serializable]
   public class ImapUpgradeConnectionException : ImapConnectionException {
     protected ImapUpgradeConnectionException(SerializationInfo info, StreamingContext context) {}
     public ImapUpgradeConnectionException() {}
     public ImapUpgradeConnectionException(string message) {}
     public ImapUpgradeConnectionException(string message, Exception innerException) {}
   }
 }
 
 namespace Smdn.Net.Imap4.Protocol.DataStructures {
   public interface IImapAppendMessage {
     IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
     DateTimeOffset? InternalDate { get; }
     long Length { get; }
 
     Stream GetMessageStream();
   }
 
+  public interface IImapNumberSet :
+    IEnumerable<long>,
+    ISerializable
+  {
+    long ConcreteCount { get; }
+    string Expression { get; }
+    bool IsEmpty { get; }
+    bool IsSingle { get; }
+    bool IsUidSet { get; }
+
+    IImapNumberSet CombineWith(IImapNumberSet other);
+    IEnumerable<IImapNumberSet> SplitIntoEach(int count);
+  }
+
   public sealed class ImapAddress {
     [Obsolete("use AtDomainList instead")]
     public string AtDomailList { get; }
     public string AtDomainList { get; }
     public string Host { get; }
     public string Mailbox { get; }
     public string Name { get; }
 
     public string GetDecodedName(EncodingSelectionCallback selectFallbackEncoding = null, bool throwIfMalformedOrUnsupported = false) {}
     public MailAddress ToMailAddress(EncodingSelectionCallback selectFallbackEncoding = null, bool throwIfMalformedOrUnsupported = false) {}
     public static MailAddressCollection ToMailAddressCollection(IEnumerable<ImapAddress> addresses, EncodingSelectionCallback selectFallbackEncoding = null, bool throwIfMalformedOrUnsupported = false) {}
     public override string ToString() {}
   }
 
   public class ImapAppendMessage : IImapAppendMessage {
     public ImapAppendMessage(Stream messageStream, long length, DateTimeOffset? internalDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
     public ImapAppendMessage(byte[] message, DateTimeOffset? internalDate = null, IEnumerable<ImapMessageFlag> flags = null) {}
 
     public IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
     public DateTimeOffset? InternalDate { get; }
     public long Length { get; }
 
     public Stream GetMessageStream() {}
   }
 
   [Serializable]
-  public class ImapAppendedUidSet : ImapSequenceSet {
-    protected ImapAppendedUidSet(SerializationInfo info, StreamingContext context) {}
-
-    public ImapSequenceSet AssignedUidSet { get; }
-    public override long ConcreteCount { get; }
-    public override bool IsEmpty { get; }
-    public override bool IsSingle { get; }
-    public override bool IsUidSet { get; }
+  public sealed class ImapAppendedUidSet : IImapNumberSet {
+    public IImapNumberSet AssignedUidSet { get; }
+    public long ConcreteCount { get; }
+    public string Expression { get; }
+    public bool IsEmpty { get; }
+    public bool IsSingle { get; }
+    public bool IsUidSet { get; }
     public long UidValidity { get; }
 
-    public override IEnumerator<long> GetEnumerator() {}
-    public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
-    public override IEnumerable<ImapSequenceSet> SplitIntoEach(int count) {}
-    public override long[] ToArray() {}
-    public override long ToNumber() {}
+    public IEnumerator<long> GetEnumerator() {}
+    public void GetObjectData(SerializationInfo info, StreamingContext context) {}
+    IImapNumberSet IImapNumberSet.CombineWith(IImapNumberSet other) {}
+    public IEnumerable<IImapNumberSet> SplitIntoEach(int count) {}
+    IEnumerator IEnumerable.GetEnumerator() {}
     public override string ToString() {}
   }
 
   [Serializable]
-  public class ImapCopiedUidSet : ImapSequenceSet {
-    protected ImapCopiedUidSet(SerializationInfo info, StreamingContext context) {}
-
-    public ImapSequenceSet AssignedUidSet { get; }
-    public override long ConcreteCount { get; }
-    public ImapSequenceSet CopiedUidSet { get; }
-    public override bool IsEmpty { get; }
-    public override bool IsSingle { get; }
-    public override bool IsUidSet { get; }
+  public sealed class ImapCopiedUidSet : IImapNumberSet {
+    public IImapNumberSet AssignedUidSet { get; }
+    public long ConcreteCount { get; }
+    public IImapNumberSet CopiedUidSet { get; }
+    public string Expression { get; }
+    public bool IsEmpty { get; }
+    public bool IsSingle { get; }
+    public bool IsUidSet { get; }
     public long UidValidity { get; }
 
-    public override IEnumerator<long> GetEnumerator() {}
-    public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
-    public override IEnumerable<ImapSequenceSet> SplitIntoEach(int count) {}
-    public override long[] ToArray() {}
-    public override long ToNumber() {}
+    public IEnumerator<long> GetEnumerator() {}
+    public void GetObjectData(SerializationInfo info, StreamingContext context) {}
+    IImapNumberSet IImapNumberSet.CombineWith(IImapNumberSet other) {}
+    public IEnumerable<IImapNumberSet> SplitIntoEach(int count) {}
+    IEnumerator IEnumerable.GetEnumerator() {}
     public override string ToString() {}
   }
 
   public sealed class ImapEnvelope {
     public IReadOnlyList<ImapAddress> Bcc { get; }
     public IReadOnlyList<ImapAddress> Cc { get; }
     public string Date { get; }
     public IReadOnlyList<ImapAddress> From { get; }
     public string InReplyTo { get; }
     public string MessageId { get; }
     public IReadOnlyList<ImapAddress> ReplyTo { get; }
     public IReadOnlyList<ImapAddress> Sender { get; }
     public string Subject { get; }
     public IReadOnlyList<ImapAddress> To { get; }
 
     public DateTimeOffset? GetDecodedDate(bool throwIfMalformed = false) {}
     public string GetDecodedSubject(EncodingSelectionCallback selectFallbackEncoding = null, bool throwIfMalformedOrUnsupported = false) {}
     public override string ToString() {}
   }
 
   public sealed class ImapListedMailbox {
     public class ListExtendedChildInfo {
       public bool Subscribed { get; }
 
       public override string ToString() {}
     }
 
-    public ImapListedMailbox(IReadOnlyStringSet<ImapMailboxFlag> nameAttributes, string hierarchyDelimiter, string name) {}
-
     public ImapListedMailbox.ListExtendedChildInfo ChildInfo { get; }
     public string HierarchyDelimiter { get; }
     public string Name { get; }
     public IReadOnlyStringSet<ImapMailboxFlag> NameAttributes { get; }
 
     public override string ToString() {}
   }
 
   [Serializable]
-  public class ImapMatchedSequenceSet : ImapSequenceSet {
+  public class ImapMatchedSequenceSet : IImapNumberSet {
     protected ImapMatchedSequenceSet(SerializationInfo info, StreamingContext context) {}
-    public ImapMatchedSequenceSet(ImapSequenceSet sequenceSet) {}
-    public ImapMatchedSequenceSet(ImapSequenceSet sequenceSet, ulong highestModSeq) {}
 
-    public override long ConcreteCount { get; }
+    public virtual long ConcreteCount { get; }
     public long? Count { get; }
+    public virtual string Expression { get; }
     public ulong? HighestModSeq { get; }
-    public override bool IsEmpty { get; }
-    public bool IsSavedResult { get; }
-    public override bool IsSingle { get; }
-    public override bool IsUidSet { get; }
+    public virtual bool IsEmpty { get; }
+    public virtual bool IsSavedResult { get; }
+    public virtual bool IsSingle { get; }
+    public virtual bool IsUidSet { get; }
     public long? Max { get; }
     public long? Min { get; }
     public string Tag { get; }
 
-    public static ImapMatchedSequenceSet CreateEmpty(bool uid) {}
-    public static ImapMatchedSequenceSet CreateSavedResult(ImapMatchedSequenceSet result) {}
-    public override IEnumerator<long> GetEnumerator() {}
-    public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
-    public override IEnumerable<ImapSequenceSet> SplitIntoEach(int count) {}
-    public override long[] ToArray() {}
-    public override long ToNumber() {}
+    public virtual IEnumerator<long> GetEnumerator() {}
+    public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
+    IImapNumberSet IImapNumberSet.CombineWith(IImapNumberSet other) {}
+    public virtual IEnumerable<IImapNumberSet> SplitIntoEach(int count) {}
+    IEnumerator IEnumerable.GetEnumerator() {}
     public override string ToString() {}
   }
 
   public class ImapMetadata {
     public const string Separator = "/";
     public const char SeparatorChar = '/';
 
-    public ImapMetadata(string entryName, ImapString @value) {}
-    public ImapMetadata(string[] hierarchicalEntryName, ImapString @value) {}
-
     public string EntryName { get; }
-    public string[] HierarchicalEntryName { get; }
+    public IReadOnlyList<string> HierarchicalEntryName { get; }
+    public static IReadOnlyList<char> InvalidEntryNameChars { get; }
     public bool IsPrivate { get; }
     public bool IsShared { get; }
     public ImapString Value { get; }
 
-    public static ImapMetadata CreateNil(string entryName) {}
-    public static ImapMetadata CreateNil(string hierarchicalEntryName, params string[] hierarchicalEntryNames) {}
-    public static ImapMetadata CreatePrivateVendorMetadata(ImapString @value, string hierarchicalEntryName, params string[] hierarchicalEntryNames) {}
-    public static ImapMetadata CreateSharedVendorMetadata(ImapString @value, string hierarchicalEntryName, params string[] hierarchicalEntryNames) {}
+    [Obsolete("This feature will be deprecated in future release.")]
+    public static ImapMetadata CreateLiteral(string entryName, string @value, Encoding charset) {}
+    [Obsolete("This feature will be deprecated in future release.")]
+    public static ImapMetadata CreateQuoted(string entryName, string @value) {}
     public static string JoinEntryName(string hierarchicalEntryName, params string[] hierarchicalEntryNames) {}
     public static string[] SplitEntryName(string entryName) {}
   }
 
-  public sealed class ImapNamespace : ICloneable {
-    public ImapNamespace(IReadOnlyList<ImapNamespaceDesc> personalNamespaces = null, IReadOnlyList<ImapNamespaceDesc> otherUsersNamespaces = null, IReadOnlyList<ImapNamespaceDesc> sharedNamespaces = null) {}
-
+  public sealed class ImapNamespace {
     public IReadOnlyList<ImapNamespaceDesc> OtherUsersNamespaces { get; }
     public IReadOnlyList<ImapNamespaceDesc> PersonalNamespaces { get; }
     public IReadOnlyList<ImapNamespaceDesc> SharedNamespaces { get; }
 
-    public ImapNamespace Clone() {}
-    object ICloneable.Clone() {}
     public override string ToString() {}
   }
 
-  public sealed class ImapNamespaceDesc : ICloneable {
-    public ImapNamespaceDesc(string prefix, string hierarchyDelimiter = null, IReadOnlyDictionary<string, IReadOnlyList<string>> extensions = null) {}
-
+  public sealed class ImapNamespaceDesc {
     public IReadOnlyDictionary<string, IReadOnlyList<string>> Extensions { get; }
     public string HierarchyDelimiter { get; }
     public string Prefix { get; }
     public string TranslatedPrefix { get; }
 
-    public ImapNamespaceDesc Clone() {}
-    object ICloneable.Clone() {}
     public override string ToString() {}
   }
 
   public sealed class ImapQuota {
-    public ImapQuota(string root, IReadOnlyList<ImapQuotaResource> resources) {}
-
-    public IReadOnlyList<ImapQuotaResource> Resources { get; }
+    public IReadOnlyList<ImapQuotaResourceUsage> Resources { get; }
     public string Root { get; }
 
     public override string ToString() {}
   }
 
-  public sealed class ImapQuotaResource {
-    public ImapQuotaResource(string name, long limit) {}
-    public ImapQuotaResource(string name, long usage, long limit) {}
+  public sealed class ImapQuotaResourceLimit {
+    public ImapQuotaResourceLimit(string name, long limit) {}
 
     public long Limit { get; }
     public string Name { get; }
-    public long Usage { get; }
 
     public override string ToString() {}
   }
 
-  [Serializable]
-  public abstract class ImapSequenceSet :
-    IEnumerable<long>,
-    ISerializable
-  {
-    protected ImapSequenceSet(SerializationInfo info, StreamingContext context) {}
-    protected ImapSequenceSet(bool isUidSet) {}
-
-    public abstract long ConcreteCount { get; }
-    public virtual bool IsEmpty { get; }
-    public abstract bool IsSingle { get; }
-    public virtual bool IsUidSet { get; }
-
-    public static ImapSequenceSet Combine(ImapSequenceSet x, ImapSequenceSet y) {}
-    public ImapSequenceSet CombineWith(ImapSequenceSet other) {}
-    public static ImapSequenceSet CreateAllSet() {}
-    public static ImapSequenceSet CreateAllSet(bool uid) {}
-    public static ImapSequenceSet CreateFromSet(bool uidSet, long from) {}
-    public static ImapSequenceSet CreateFromSet(long from) {}
-    public static ImapSequenceSet CreateRangeSet(bool uidSet, long from, long to) {}
-    public static ImapSequenceSet CreateRangeSet(long from, long to) {}
-    public static ImapSequenceSet CreateSet(IEnumerable<long> numbers) {}
-    public static ImapSequenceSet CreateSet(bool uidSet, IEnumerable<long> numbers) {}
-    public static ImapSequenceSet CreateSet(bool uidSet, long number, params long[] numbers) {}
-    public static ImapSequenceSet CreateSet(bool uidSet, long[] numbers) {}
-    public static ImapSequenceSet CreateSet(bool uidSet, long[] numbers, int start, int count) {}
-    public static ImapSequenceSet CreateSet(long number, params long[] numbers) {}
-    public static ImapSequenceSet CreateSet(long[] numbers) {}
-    public static ImapSequenceSet CreateSet(long[] numbers, int start, int count) {}
-    public static ImapSequenceSet CreateToSet(bool uidSet, long to) {}
-    public static ImapSequenceSet CreateToSet(long to) {}
-    public static ImapSequenceSet CreateUidAllSet() {}
-    public static ImapSequenceSet CreateUidFromSet(long from) {}
-    public static ImapSequenceSet CreateUidRangeSet(long from, long to) {}
-    public static ImapSequenceSet CreateUidSet(IEnumerable<long> numbers) {}
-    public static ImapSequenceSet CreateUidSet(long number, params long[] numbers) {}
-    public static ImapSequenceSet CreateUidSet(long[] numbers) {}
-    public static ImapSequenceSet CreateUidSet(long[] numbers, int start, int count) {}
-    public static ImapSequenceSet CreateUidToSet(long to) {}
-    public static ImapSequenceSet FromUri(Uri uri) {}
-    public abstract IEnumerator<long> GetEnumerator();
-    public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
-    public virtual IEnumerable<ImapSequenceSet> SplitIntoEach(int count) {}
-    IEnumerator IEnumerable.GetEnumerator() {}
-    public abstract long[] ToArray();
-    public virtual long ToNumber() {}
-    public abstract string ToString();
-    public static ImapSequenceSet operator + (ImapSequenceSet x, ImapSequenceSet y) {}
-  }
-
-  public sealed class ImapStatusAttributes {
-    public ImapStatusAttributes() {}
-
-    public ulong? HighestModSeq { get; }
-    public long? Messages { get; }
-    public long? Recent { get; }
-    public long? UidNext { get; }
-    public long? UidValidity { get; }
-    public long? Unseen { get; }
-
-    public override string ToString() {}
+  public static class ImapSequenceSet {
+    public static IImapNumberSet All(bool asUidSet = false) {}
+    [Obsolete("use All() instead", true)]
+    public static IImapNumberSet CreateAllSet() {}
+    [Obsolete("use ImapUidSet.All() or ImapSequenceSet.All() instead")]
+    public static IImapNumberSet CreateAllSet(bool uid) {}
+    [Obsolete("use ImapUidSet.From() or ImapSequenceSet.From() instead")]
+    public static IImapNumberSet CreateFromSet(bool uidSet, long from) {}
+    [Obsolete("use From() instead", true)]
+    public static IImapNumberSet CreateFromSet(long from) {}
+    [Obsolete("use ImapUidSet.Range() or ImapSequenceSet.Range() instead")]
+    public static IImapNumberSet CreateRangeSet(bool uidSet, long from, long to) {}
+    [Obsolete("use Range() instead", true)]
+    public static IImapNumberSet CreateRangeSet(long from, long to) {}
+    [Obsolete("use Of() instead", true)]
+    public static IImapNumberSet CreateSet(IEnumerable<long> numbers) {}
+    [Obsolete("use ImapUidSet.Of() or ImapSequenceSet.Of() instead", true)]
+    public static IImapNumberSet CreateSet(bool uidSet, IEnumerable<long> numbers) {}
+    [Obsolete("use ImapUidSet.Of() or ImapSequenceSet.Of() instead", true)]
+    public static IImapNumberSet CreateSet(bool uidSet, long number, params long[] numbers) {}
+    [Obsolete("use ImapUidSet.Of() or ImapSequenceSet.Of() instead", true)]
+    public static IImapNumberSet CreateSet(bool uidSet, long[] numbers) {}
+    [Obsolete("use ImapUidSet.Of() or ImapSequenceSet.Of() instead", true)]
+    public static IImapNumberSet CreateSet(bool uidSet, long[] numbers, int start, int count) {}
+    [Obsolete("use Of() instead", true)]
+    public static IImapNumberSet CreateSet(long number, params long[] numbers) {}
+    [Obsolete("use Of() instead", true)]
+    public static IImapNumberSet CreateSet(long[] numbers) {}
+    [Obsolete("use Of() instead", true)]
+    public static IImapNumberSet CreateSet(long[] numbers, int start, int count) {}
+    [Obsolete("use ImapUidSet.To() or ImapSequenceSet.To() instead")]
+    public static IImapNumberSet CreateToSet(bool uidSet, long to) {}
+    [Obsolete("use ImapUidSet.To()", true)]
+    public static IImapNumberSet CreateToSet(long to) {}
+    [Obsolete("use ImapUidSet.All() instead", true)]
+    public static IImapNumberSet CreateUidAllSet() {}
+    [Obsolete("use ImapUidSet.From() instead", true)]
+    public static IImapNumberSet CreateUidFromSet(long from) {}
+    [Obsolete("use ImapUidSet.Range() instead", true)]
+    public static IImapNumberSet CreateUidRangeSet(long from, long to) {}
+    [Obsolete("use ImapUidSet.Of() instead", true)]
+    public static IImapNumberSet CreateUidSet(IEnumerable<long> numbers) {}
+    [Obsolete("use ImapUidSet.Of() instead", true)]
+    public static IImapNumberSet CreateUidSet(long number, params long[] numbers) {}
+    [Obsolete("use ImapUidSet.Of() instead", true)]
+    public static IImapNumberSet CreateUidSet(long[] numbers) {}
+    [Obsolete("use ImapUidSet.Of() instead", true)]
+    public static IImapNumberSet CreateUidSet(long[] numbers, int start, int count) {}
+    [Obsolete("use ImapUidSet.To() instead", true)]
+    public static IImapNumberSet CreateUidToSet(long to) {}
+    public static IImapNumberSet Empty(bool asUidSet = false) {}
+    public static IImapNumberSet From(long from, bool asUidSet = false) {}
+    [Obsolete("use ImapUidSet.FromUri() instead", true)]
+    public static IImapNumberSet FromUri(Uri uri) {}
+    public static IImapNumberSet Of(ArraySegment<long> numbers, bool asUidSet = false) {}
+    public static IImapNumberSet Of(IEnumerable<long> numbers, bool asUidSet = false) {}
+    public static IImapNumberSet Of(bool asUidSet, long number, params long[] numbers) {}
+    public static IImapNumberSet Of(long number, bool asUidSet = false) {}
+    public static IImapNumberSet Of(long number, params long[] numbers) {}
+    public static IImapNumberSet Range(long from, long to, bool asUidSet = false) {}
+    public static IImapNumberSet To(long to, bool asUidSet = false) {}
   }
 
   public sealed class ImapThreadList : IEnumerable<ImapThreadList> {
     public IReadOnlyList<ImapThreadList> Children { get; }
     public bool IsRoot { get; }
     public bool IsUidList { get; }
     public long Number { get; }
 
     public IEnumerator<ImapThreadList> GetEnumerator() {}
     IEnumerator IEnumerable.GetEnumerator() {}
-    public ImapSequenceSet ToSequenceSet() {}
+    public IImapNumberSet ToSequenceSet() {}
     public override string ToString() {}
     public void Traverse(Action<ImapThreadList> action) {}
   }
 
-  public struct ImapFetchRange :
+  public static class ImapUidSet {
+    public static IImapNumberSet All() {}
+    public static IImapNumberSet Empty() {}
+    public static IImapNumberSet From(long from) {}
+    public static IImapNumberSet FromUri(Uri uri) {}
+    public static IImapNumberSet Of(ArraySegment<long> uids) {}
+    public static IImapNumberSet Of(IEnumerable<long> uids) {}
+    public static IImapNumberSet Of(long uid) {}
+    public static IImapNumberSet Of(long uid, params long[] uids) {}
+    public static IImapNumberSet Range(long from, long to) {}
+    public static IImapNumberSet To(long to) {}
+  }
+
+  public readonly struct ImapFetchRange :
     IEquatable<ImapFetchRange>,
     IFormattable
   {
+    public static readonly ImapFetchRange All; // = "<0>"
+
     public ImapFetchRange(long start) {}
     public ImapFetchRange(long start, long length) {}
 
     public bool IsLengthSpecified { get; }
-    public long? Length { get; set; }
-    public long Start { get; set; }
+    public bool IsPartial { get; }
+    public long? Length { get; }
+    public long Start { get; }
 
     public bool Equals(ImapFetchRange other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     public override string ToString() {}
     public string ToString(string format) {}
     public string ToString(string format, IFormatProvider formatProvider) {}
   }
+
+  public readonly struct ImapQuotaResourceUsage {
+    public long Limit { get; }
+    public string Name { get; }
+    public long Usage { get; }
+    public double UsageRatio { get; }
+
+    public override string ToString() {}
+  }
 }
 
 namespace Smdn.Net.Imap4.Protocol.DataStructures.BodyStructures {
   public interface IImapBodyStructure : IImapUrl {
     bool HasEncapsulatedMessage { get; }
     bool IsMultiPart { get; }
     MimeType MediaType { get; }
     IImapBodyStructure ParentStructure { get; }
     string Section { get; }
   }
 
   public interface IImapExtendedBodyStructure : IImapBodyStructure {
     ImapBodyDisposition Disposition { get; }
     IReadOnlyList<ImapData> Extensions { get; }
     IReadOnlyList<string> Languages { get; }
     Uri Location { get; }
   }
 
   public sealed class ImapBodyDisposition {
     public string FileName { get; }
     public bool IsAttachment { get; }
     public bool IsInline { get; }
     public IReadOnlyDictionary<string, string> Parameters { get; }
     public string Type { get; }
 
     public override string ToString() {}
   }
 
   public static class ImapBodyStructureUtils {
     public static IImapBodyStructure Find(this IImapBodyStructure bodyStructure, MimeType mediaType) {}
     public static IImapBodyStructure Find(this IImapBodyStructure bodyStructure, Predicate<IImapBodyStructure> match) {}
     public static IEnumerable<IImapBodyStructure> FindAll(this IImapBodyStructure bodyStructure, MimeType mediaType) {}
     public static IEnumerable<IImapBodyStructure> FindAll(this IImapBodyStructure bodyStructure, Predicate<IImapBodyStructure> match) {}
     public static IImapBodyStructure FindSection(this IImapBodyStructure bodyStructure, params int[] subSections) {}
     public static IImapBodyStructure FindSection(this IImapBodyStructure bodyStructure, string section) {}
     public static string GetContentFileName(this IImapBodyStructure bodyStructure, EncodingSelectionCallback selectFallbackEncoding = null, bool throwIfMalformedOrUnsupported = false) {}
     public static IImapBodyStructure GetRootStructure(this IImapBodyStructure bodyStructure) {}
     public static string GetValidatedSectionSpecOfSectionPart(string sectionSpec) {}
     public static void Traverse(this IImapBodyStructure bodyStructure, Action<IImapBodyStructure> action) {}
   }
 
   public sealed class ImapExtendedMessageRfc822BodyStructure :
     ImapMessageRfc822BodyStructure,
     IImapExtendedBodyStructure
   {
     public ImapBodyDisposition Disposition { get; }
     public IReadOnlyList<ImapData> Extensions { get; }
     public IReadOnlyList<string> Languages { get; }
     public Uri Location { get; }
     public string MD5 { get; }
 
     public override string ToString() {}
   }
 
   public sealed class ImapExtendedMultiPartBodyStructure :
     ImapMultiPartBodyStructure,
     IImapExtendedBodyStructure
   {
     public ImapBodyDisposition Disposition { get; }
     public IReadOnlyList<ImapData> Extensions { get; }
     public IReadOnlyList<string> Languages { get; }
     public Uri Location { get; }
     public IReadOnlyDictionary<string, string> Parameters { get; }
 
     public override string ToString() {}
   }
 
   public sealed class ImapExtendedSinglePartBodyStructure :
     ImapSinglePartBodyStructure,
     IImapExtendedBodyStructure
   {
     public ImapBodyDisposition Disposition { get; }
     public IReadOnlyList<ImapData> Extensions { get; }
     public IReadOnlyList<string> Languages { get; }
     public Uri Location { get; }
     public string MD5 { get; }
 
     public override string ToString() {}
   }
 
   public class ImapMessageRfc822BodyStructure : ImapSinglePartBodyStructure {
     [Obsolete("refer EncapsulatedMessageStructure instead")]
     public IImapBodyStructure BodyStructure { get; }
     public IImapBodyStructure EncapsulatedMessageStructure { get; }
     public ImapEnvelope Envelope { get; }
     public override bool HasEncapsulatedMessage { get; }
 
     public override string ToString() {}
   }
 
   public class ImapMultiPartBodyStructure : IImapBodyStructure {
     public bool HasEncapsulatedMessage { get; }
     public bool IsMultiPart { get; }
     public MimeType MediaType { get; }
     public IReadOnlyList<IImapBodyStructure> NestedPartStructures { get; }
     [Obsolete("refer NestedPartStructures instead")]
     public IReadOnlyList<IImapBodyStructure> NestedStructures { get; }
     public IImapBodyStructure ParentStructure { get; }
     public string Section { get; }
     public Uri Url { get; }
 
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
   }
 
   public class ImapSinglePartBodyStructure : IImapBodyStructure {
     public string Description { get; }
     public string Encoding { get; }
     public virtual bool HasEncapsulatedMessage { get; }
     public string Id { get; }
     public bool IsMultiPart { get; }
     public long LineCount { get; }
     public MimeType MediaType { get; }
     public IReadOnlyDictionary<string, string> Parameters { get; }
     public IImapBodyStructure ParentStructure { get; }
     public string Section { get; }
     public long Size { get; }
     public Uri Url { get; }
 
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
   }
 }
 
 namespace Smdn.Net.Imap4.Protocol.DataStructures.MessageAttributes {
   public interface IImapMessageAttributeCollection<TMessageAttributes> where TMessageAttributes : ImapMessageAttributesBase {
     void Add(TMessageAttributes @value);
     TMessageAttributes Find(long sequence);
   }
 
   public interface IImapMessageDynamicAttributes {
     IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
     ulong ModSeq { get; }
     long Sequence { get; }
   }
 
   public interface IImapMessageStaticAttributes {
     IReadOnlyCollection<string> BinarySizeSpecifiers { get; }
     IImapBodyStructure BodyStructure { get; }
     ImapEnvelope Envelope { get; }
     DateTimeOffset? InternalDate { get; }
     long Rfc822Size { get; }
     long Sequence { get; }
     long Uid { get; }
 
     long GetBinarySizeOf(string section);
   }
 
   public sealed class ImapMessageAttributes :
     ImapMessageAttributesBase,
     IImapMessageDynamicAttributes,
     IImapMessageStaticAttributes,
     IImapUrl
   {
     public IReadOnlyCollection<string> BinarySizeSpecifiers { get; }
     public IImapBodyStructure BodyStructure { get; }
     public ImapEnvelope Envelope { get; }
     public IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
     public DateTimeOffset? InternalDate { get; }
     public ulong ModSeq { get; }
     public long Rfc822Size { get; }
     public long Uid { get; }
     public Uri Url { get; }
 
     public long GetBinarySizeOf(string section) {}
     public long GetFirstBinarySize() {}
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
   }
 
   public abstract class ImapMessageAttributesBase {
     public long Sequence { get; }
 
     protected IImapUrlSearchQuery GetSequenceNumberSearchCriteria() {}
     public abstract string ToString();
   }
 
   public class ImapMessageBodyAttributes : ImapMessageAttributesBase {
     public IReadOnlyCollection<string> BodySpecifiers { get; }
 
     public long GetBodyLengthOf(string specifier) {}
     public long GetFirstBodyLength() {}
     public void ReadBodyOf(string specifier, Action<Stream> readBody) {}
     public void ReadFirstBody(Action<Stream> readBody) {}
     public override string ToString() {}
   }
 
   public sealed class ImapMessageDynamicAttributes :
     ImapMessageAttributesBase,
     IImapMessageDynamicAttributes
   {
     public IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
     public ulong ModSeq { get; }
 
     public override string ToString() {}
   }
 
   public sealed class ImapMessageFullAttributes :
     ImapMessageBodyAttributes,
     IImapAppendMessage,
     IImapMessageDynamicAttributes,
     IImapMessageStaticAttributes,
     IImapUrl
   {
     public IReadOnlyCollection<string> BinarySizeSpecifiers { get; }
     public IImapBodyStructure BodyStructure { get; }
     public ImapEnvelope Envelope { get; }
     public IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
     public DateTimeOffset? InternalDate { get; }
     public ulong ModSeq { get; }
     public long Rfc822Size { get; }
     long IImapAppendMessage.Length { get; }
     public long Uid { get; }
     public Uri Url { get; }
 
     public long GetBinarySizeOf(string section) {}
     public long GetFirstBinarySize() {}
     Stream IImapAppendMessage.GetMessageStream() {}
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
   }
 
   public sealed class ImapMessageNullAttributes : ImapMessageBodyAttributes {
     public override string ToString() {}
   }
 
   public sealed class ImapMessageStaticAttributes :
     ImapMessageAttributesBase,
     IImapMessageStaticAttributes,
     IImapUrl
   {
     public IReadOnlyCollection<string> BinarySizeSpecifiers { get; }
     public IImapBodyStructure BodyStructure { get; }
     public ImapEnvelope Envelope { get; }
     public DateTimeOffset? InternalDate { get; }
     public long Rfc822Size { get; }
     public long Uid { get; }
     public Uri Url { get; }
 
     public long GetBinarySizeOf(string section) {}
     public long GetFirstBinarySize() {}
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
   }
 }
 
 namespace Smdn.Net.Imap4.Protocol.Session {
   public interface IImapSessionProfile {
     bool AllowInsecureLogin { get; }
     Uri Authority { get; }
     ICredentialsByHost Credentials { get; }
     int ReceiveTimeout { get; }
     int SendTimeout { get; }
     int Timeout { get; }
     bool UseDeflateIfAvailable { get; }
     bool UseTlsIfAvailable { get; }
     IReadOnlyList<string> UsingSaslMechanisms { get; }
   }
 
   public enum ImapSessionState : int {
     Authenticated = 2,
+    Disconnected = 4,
     NotAuthenticated = 1,
     NotConnected = 0,
     Selected = 3,
   }
 
   public class ImapFetchMessageBodyStream : Stream {
     public static readonly int DefaultFetchBlockSize = 10240;
 
-    internal protected ImapFetchMessageBodyStream(ImapSession session, bool fetchPeek, ImapSequenceSet fetchMessageUid, int fetchBlockSize) {}
-    internal protected ImapFetchMessageBodyStream(ImapSession session, bool fetchPeek, ImapSequenceSet fetchMessageUid, string fetchSectionOrHeaderFields, ImapFetchRange? fetchRange, int fetchBlockSize) {}
-    internal protected ImapFetchMessageBodyStream(ImapSession session, bool fetchPeek, ImapSequenceSet fetchMessageUid, string fetchSectionOrHeaderFields, ImapFetchRange? fetchRange, int fetchBlockSize, CancellationToken cancellationToken) {}
+    internal protected ImapFetchMessageBodyStream(ImapSession session, IImapNumberSet uid, bool peek = false, string sectionSpecifier = null, ImapFetchRange range = default, int blockSize = 10240, CancellationToken cancellationToken = default) {}
 
+    internal protected long BlockSize { get; }
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     protected CancellationToken CancellationToken { get; }
-    internal protected long FetchBlockSize { get; }
     public override long Length { get; }
     public override long Position { get; set; }
     public override int ReadTimeout { get; set; }
     protected ImapSession Session { get; }
     public override int WriteTimeout { get; set; }
 
     public override void Close() {}
+    protected virtual Exception CreateFetchFailureException(ImapCommandResult result) {}
+    protected virtual Exception CreateNoSuchMessageException(ImapCommandResult result) {}
+    protected virtual Exception CreateTimeoutException(TimeoutException baseException) {}
+    protected virtual Exception CreateUnexpectedException(Exception baseException) {}
     protected void DetachFromSession() {}
     protected override void Dispose(bool disposing) {}
     public override void Flush() {}
-    protected virtual Exception GetFetchFailureException(ImapCommandResult result) {}
-    protected virtual Exception GetNoSuchMessageException(ImapCommandResult result) {}
-    protected virtual Exception GetTimeoutException(TimeoutException ex) {}
-    protected virtual Exception GetUnexpectedException(ImapException ex) {}
-    internal protected virtual ImapCommandResult Prepare(ImapFetchDataItems fetchDataItems, out ImapMessageAttributes messageAttributes) {}
-    public override int Read(byte[] dest, int offset, int count) {}
+    internal protected virtual (ImapCommandResult result, ImapMessageAttributes messageAttributes) Prepare(ImapFetchDataItems fetchDataItems) {}
+    public override int Read(byte[] buffer, int offset, int count) {}
     public void ReadToEnd(BinaryWriter destination) {}
     public void ReadToEnd(Stream destination) {}
     internal protected virtual void ReportFetchedOctetCount(long fetchedOctetCount, long totalOctetCount) {}
     public override long Seek(long offset, SeekOrigin origin) {}
     public override void SetLength(long @value) {}
     public override void Write(byte[] buffer, int offset, int count) {}
   }
 
   [Serializable]
   public class ImapLoginReferralException : ImapReferralException {
     protected ImapLoginReferralException(SerializationInfo info, StreamingContext context) {}
 
     public Uri ReferToUri { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public class ImapMailboxReferralException : ImapReferralException {
     protected ImapMailboxReferralException(SerializationInfo info, StreamingContext context) {}
 
     public IReadOnlyList<Uri> Referrals { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   public sealed class ImapMailboxStatus : IImapUrl {
     public IReadOnlyStringSet<ImapMessageFlag> ApplicableFlags { get; }
     public long ExistsMessage { get; }
     public long FirstUnseen { get; }
     public IReadOnlyStringSet<ImapMailboxFlag> Flags { get; }
     public string HierarchyDelimiter { get; }
     public ulong HighestModSeq { get; }
     public bool IsInbox { get; }
     public bool IsNonHierarchical { get; }
     public bool IsUnselectable { get; }
     public string LeafName { get; }
     public bool ModificationSequences { get; }
     public string Name { get; }
     public IReadOnlyStringSet<ImapMessageFlag> PermanentFlags { get; }
     public bool ReadOnly { get; }
     public long RecentMessage { get; }
     public string SuperiorName { get; }
     public long UidNext { get; }
     public bool UidPersistent { get; }
     public long UidValidity { get; }
     public long UnseenMessage { get; }
     public Uri Url { get; }
 
     public bool NameEquals(ImapMailboxStatus other) {}
     public bool NameEquals(string otherMailboxName) {}
     void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
     public override string ToString() {}
   }
 
   [Serializable]
   public abstract class ImapReferralException : ImapException {
     protected ImapReferralException(SerializationInfo info, StreamingContext context) {}
     protected ImapReferralException(string message) {}
     protected ImapReferralException(string message, Exception innerException) {}
   }
 
   public sealed class ImapSession :
     IConnectionInfo,
     IDisposable
   {
     public enum CopyMoveCommand : int {
       Copy = 0,
       Move = 1,
     }
 
-    public ImapSession(string host, int port = 143, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool handlesReferralAsException = false, UpgradeConnectionStreamCallback createAuthenticatedStream = null) {}
+    public ImapSession() {}
+    public ImapSession(string hostname, int port = -1, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool handlesReferralAsException = false, UpgradeConnectionStreamCallback createAuthenticatedStream = null) {}
 
     public ImapCollationAlgorithm ActiveComparator { get; }
     public Uri Authority { get; }
     public bool HandlesIncapableAsException { get; set; }
     public bool HandlesReferralAsException { get; set; }
     public IReadOnlyDictionary<string, string> HierarchyDelimiters { get; }
-    public bool IsDisposed { get; }
     public bool IsIdling { get; }
     public bool IsSecureConnection { get; }
     public bool IsTransactionProceeding { get; }
     public ImapNamespace Namespaces { get; }
     public int ReceiveTimeout { get; set; }
     public string SelectedLanguage { get; }
     public ImapMailboxStatus SelectedMailbox { get; }
     public int SendTimeout { get; set; }
     public IReadOnlyStringSet<ImapCapability> ServerCapabilities { get; }
     public IReadOnlyDictionary<string, string> ServerID { get; }
     string IConnectionInfo.Host { get; }
     int IConnectionInfo.Port { get; }
     public ImapSessionState State { get; }
     public int TransactionTimeout { get; set; }
 
     public ImapCommandResult Append(IEnumerable<IImapAppendMessage> messages, ImapMailboxStatus mailbox, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult Append(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult Append(IImapAppendMessage message, ImapMailboxStatus mailbox, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult Append(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult AppendBinary(IEnumerable<IImapAppendMessage> messages, ImapMailboxStatus mailbox, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult AppendBinary(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult AppendBinary(IImapAppendMessage message, ImapMailboxStatus mailbox, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult AppendBinary(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids) {}
     public ImapCommandResult AppendBinaryTryCreateMailbox(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
     public ImapCommandResult AppendBinaryTryCreateMailbox(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
     public ImapCommandResult AppendTryCreateMailbox(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
     public ImapCommandResult AppendTryCreateMailbox(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
     public ImapCommandResult Authenticate(ImapAuthenticationMechanism authenticationMechanism, ICredentialsByHost credentials, string username = null, bool reissueCapability = false, CancellationToken cancellationToken = default) {}
     public ImapCommandResult Authenticate(SaslClientMechanism specificAuthenticationMechanism, bool reissueCapability = false, CancellationToken cancellationToken = default) {}
     public ImapCommandResult Capability() {}
     public ImapCommandResult Capability(out IReadOnlyStringSet<ImapCapability> capabilities) {}
     public ImapCommandResult Check() {}
     public ImapCommandResult Close() {}
     public ImapCommandResult Comparator(ImapCollationAlgorithm comparator, params ImapCollationAlgorithm[] comparators) {}
     public ImapCommandResult Comparator(out IReadOnlyList<ImapCollationAlgorithm> matchingComparators, ImapCollationAlgorithm comparator, params ImapCollationAlgorithm[] comparators) {}
     public ImapCommandResult Comparator(out ImapCollationAlgorithm activeComparator, out IReadOnlyList<ImapCollationAlgorithm> matchingComparators, ImapCollationAlgorithm comparator, params ImapCollationAlgorithm[] comparators) {}
     public ImapCommandResult ComparatorGetActive() {}
     public ImapCommandResult ComparatorGetActive(out ImapCollationAlgorithm activeComparator) {}
     public ImapCommandResult Compress(ImapCompressionMechanism compressionMechanism) {}
-    public ImapCommandResult Copy(ImapSequenceSet sequenceOrUidSet, ImapMailboxStatus mailbox) {}
-    public ImapCommandResult Copy(ImapSequenceSet sequenceOrUidSet, ImapMailboxStatus mailbox, out ImapCopiedUidSet copiedUids) {}
-    public ImapCommandResult Copy(ImapSequenceSet sequenceOrUidSet, string mailboxName) {}
-    public ImapCommandResult Copy(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids) {}
-    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, ImapMailboxStatus mailbox) {}
-    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, ImapMailboxStatus mailbox, out ImapCopiedUidSet copiedUids) {}
-    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, string mailboxName) {}
-    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids) {}
-    public ImapCommandResult CopyMoveTryCreateMailbox(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
-    public ImapCommandResult CopyMoveTryCreateMailbox(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
-    public ImapCommandResult CopyTryCreateMailbox(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
-    public ImapCommandResult CopyTryCreateMailbox(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
+    public Task ConnectAsync(string hostname, int port = -1, ResolveHostAddressCallback resolveHostAddress = null, UpgradeConnectionStreamCallback createAuthenticatedStream = null, CancellationToken cancellationToken = default) {}
+    public ImapCommandResult Copy(IImapNumberSet sequenceOrUidSet, ImapMailboxStatus mailbox) {}
+    public ImapCommandResult Copy(IImapNumberSet sequenceOrUidSet, ImapMailboxStatus mailbox, out ImapCopiedUidSet copiedUids) {}
+    public ImapCommandResult Copy(IImapNumberSet sequenceOrUidSet, string mailboxName) {}
+    public ImapCommandResult Copy(IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids) {}
+    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, IImapNumberSet sequenceOrUidSet, ImapMailboxStatus mailbox) {}
+    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, IImapNumberSet sequenceOrUidSet, ImapMailboxStatus mailbox, out ImapCopiedUidSet copiedUids) {}
+    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, IImapNumberSet sequenceOrUidSet, string mailboxName) {}
+    public ImapCommandResult CopyMove(ImapSession.CopyMoveCommand command, IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids) {}
+    public ImapCommandResult CopyMoveTryCreateMailbox(ImapSession.CopyMoveCommand command, IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
+    public ImapCommandResult CopyMoveTryCreateMailbox(ImapSession.CopyMoveCommand command, IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
+    public ImapCommandResult CopyTryCreateMailbox(IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
+    public ImapCommandResult CopyTryCreateMailbox(IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
     public ImapCommandResult Create(string mailboxName) {}
     public ImapCommandResult Create(string mailboxName, out ImapMailboxStatus createdMailbox) {}
+    public static Task<ImapSession> CreateAsync(IImapSessionProfile profile, SaslClientMechanism authMechanism = null, ResolveHostAddressCallback resolveHostAddress = null, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
     public ImapCommandResult CreateSpecialUse(string mailboxName, IEnumerable<ImapMailboxFlag> useFlags) {}
     public ImapCommandResult CreateSpecialUse(string mailboxName, IEnumerable<ImapMailboxFlag> useFlags, out ImapMailboxStatus createdMailbox) {}
     public ImapCommandResult CreateSpecialUse(string mailboxName, out ImapMailboxStatus createdMailbox, params ImapMailboxFlag[] useFlags) {}
     public ImapCommandResult CreateSpecialUse(string mailboxName, params ImapMailboxFlag[] useFlags) {}
     public ImapCommandResult Delete(ImapMailboxStatus mailbox) {}
     public ImapCommandResult Delete(string mailboxName) {}
     public void Disconnect(bool logout = true) {}
+    public void Dispose() {}
     public ImapCommandResult ESearch(out ImapMatchedSequenceSet matched, ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, Encoding charset = null) {}
     public ImapCommandResult ESort(out ImapMatchedSequenceSet matched, ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, Encoding charset = null) {}
     public ImapCommandResult Enable(out IReadOnlyStringSet<ImapCapability> enabledCapabilities, params string[] capabilityNames) {}
     public ImapCommandResult Enable(params string[] capabilityNames) {}
     public ImapCommandResult Examine(ImapMailboxStatus mailbox) {}
     public ImapCommandResult Examine(string mailboxName) {}
     public ImapCommandResult ExamineCondStore(ImapMailboxStatus mailbox) {}
     public ImapCommandResult ExamineCondStore(string mailboxName) {}
     public ImapCommandResult Expunge() {}
     public ImapCommandResult Expunge(out IReadOnlyList<long> expungedMessages) {}
-    public ImapCommandResult Fetch(ImapSequenceSet sequenceOrUidSet, ImapFetchDataItems messageDataItems) {}
-    public ImapCommandResult Fetch<TMessageAttributes>(ImapSequenceSet sequenceOrUidSet, ImapFetchDataItems messageDataItems, out TMessageAttributes[] messages) where TMessageAttributes : ImapMessageAttributesBase {}
-    public ImapCommandResult FetchChangedSince<TMessageAttributes>(ImapSequenceSet sequenceOrUidSet, ImapFetchDataItems messageDataItems, ulong modSeq, out TMessageAttributes[] messages) where TMessageAttributes : ImapMessageAttributesBase {}
+    public ImapCommandResult Fetch(IImapNumberSet sequenceOrUidSet, ImapFetchDataItems messageDataItems) {}
+    public ImapCommandResult Fetch<TMessageAttributes>(IImapNumberSet sequenceOrUidSet, ImapFetchDataItems messageDataItems, out TMessageAttributes[] messages) where TMessageAttributes : ImapMessageAttributesBase {}
+    public ImapCommandResult FetchChangedSince<TMessageAttributes>(IImapNumberSet sequenceOrUidSet, ImapFetchDataItems messageDataItems, ulong modSeq, out TMessageAttributes[] messages) where TMessageAttributes : ImapMessageAttributesBase {}
     public ImapCommandResult GenericCommand(string command, out IReadOnlyList<ImapServerDataResponse> dataResponses, params ImapString[] arguments) {}
     public ImapCommandResult GenericCommand(string command, params ImapString[] arguments) {}
     public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, IReadOnlyCollection<string> entrySpecifiers, ImapGetMetadataOptions options, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, IReadOnlyCollection<string> entrySpecifiers, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, string entrySpecifier, ImapGetMetadataOptions options, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, string entrySpecifier, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadata(string mailboxName, IReadOnlyCollection<string> entrySpecifiers, ImapGetMetadataOptions options, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadata(string mailboxName, IReadOnlyCollection<string> entrySpecifiers, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadata(string mailboxName, string entrySpecifier, ImapGetMetadataOptions options, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadata(string mailboxName, string entrySpecifier, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadataServer(IReadOnlyCollection<string> entrySpecifiers, ImapGetMetadataOptions options, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadataServer(IReadOnlyCollection<string> entrySpecifiers, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadataServer(string entrySpecifier, ImapGetMetadataOptions options, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetMetadataServer(string entrySpecifier, out IReadOnlyList<ImapMetadata> metadata) {}
     public ImapCommandResult GetQuota(string quotaRoot, out ImapQuota quota) {}
     public ImapCommandResult GetQuotaRoot(ImapMailboxStatus mailbox, out IReadOnlyDictionary<string, IReadOnlyList<ImapQuota>> quotaRoots) {}
     public ImapCommandResult GetQuotaRoot(string mailboxName, out IReadOnlyDictionary<string, IReadOnlyList<ImapQuota>> quotaRoots) {}
     public ImapCommandResult ID(IReadOnlyDictionary<string, string> clientParameterList) {}
     public ImapCommandResult ID(IReadOnlyDictionary<string, string> clientParameterList, out IReadOnlyDictionary<string, string> serverParameterList) {}
     public ImapCommandResult Idle(Predicate<ImapResponse> keepIdlePredicate) {}
     public ImapCommandResult Idle(TimeSpan idleTimeout, Predicate<ImapResponse> keepIdlePredicate = null) {}
     public ImapCommandResult Idle(int idleMillisecondsTimeout, Predicate<ImapResponse> keepIdlePredicate = null) {}
     public Task<ImapCommandResult> IdleAsync(CancellationToken stopIdleCancellationToken) {}
     public Task<ImapCommandResult> IdleAsync(Predicate<ImapResponse> keepIdlePredicate) {}
     public Task<ImapCommandResult> IdleAsync(Predicate<ImapResponse> keepIdlePredicate, CancellationToken stopIdleCancellationToken) {}
     public ImapCommandResult Language(CultureInfo cultureInfo, params CultureInfo[] cultureInfos) {}
     public ImapCommandResult Language(out string selectedLanguageTag, CultureInfo cultureInfo, params CultureInfo[] cultureInfos) {}
     public ImapCommandResult Language(out string selectedLanguageTag, string languageRange, params string[] languageRanges) {}
     public ImapCommandResult Language(string languageRange, params string[] languageRanges) {}
     public ImapCommandResult LanguageListSupported(out IReadOnlyList<string> supportedLanguageTags) {}
     public ImapCommandResult LanguageSelectDefault() {}
     public ImapCommandResult LanguageSelectDefault(out string selectedLanguageTag) {}
     public ImapCommandResult List(ImapMailboxStatus mailbox) {}
     public ImapCommandResult List(string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult List(string referenceName, string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult ListAll(out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult ListExtended(ImapListReturnOptions returnOptions, out IReadOnlyList<ImapMailboxStatus> mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
     public ImapCommandResult ListExtended(ImapListSelectionOptions selectionOptions, ImapListReturnOptions returnOptions, out IReadOnlyList<ImapMailboxStatus> mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
     public ImapCommandResult ListExtended(ImapListSelectionOptions selectionOptions, out IReadOnlyList<ImapMailboxStatus> mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
     public ImapCommandResult ListExtended(out IReadOnlyList<ImapMailboxStatus> mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
     public ImapCommandResult ListExtended(string mailboxNamePattern, ImapListReturnOptions returnOptions, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult ListExtended(string mailboxNamePattern, ImapListSelectionOptions selectionOptions, ImapListReturnOptions returnOptions, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult ListExtended(string mailboxNamePattern, ImapListSelectionOptions selectionOptions, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult ListExtended(string mailboxNamePattern, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult ListExtended(string referenceName, IReadOnlyCollection<string> mailboxNamePatterns, ImapListSelectionOptions selectionOptions, ImapListReturnOptions returnOptions, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult ListRoot(out ImapListedMailbox root) {}
     public ImapCommandResult ListRoot(string referenceName, out ImapListedMailbox root) {}
     public ImapCommandResult Login(ICredentialsByHost credentials, string username = null, bool reissueCapability = false) {}
     public ImapCommandResult Logout() {}
     public ImapCommandResult Lsub(ImapMailboxStatus mailbox) {}
     public ImapCommandResult Lsub(string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult Lsub(string referenceName, string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult LsubAll(out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
-    public ImapCommandResult Move(ImapSequenceSet sequenceOrUidSet, ImapMailboxStatus mailbox) {}
-    public ImapCommandResult Move(ImapSequenceSet sequenceOrUidSet, ImapMailboxStatus mailbox, out ImapCopiedUidSet copiedUids) {}
-    public ImapCommandResult Move(ImapSequenceSet sequenceOrUidSet, string mailboxName) {}
-    public ImapCommandResult Move(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids) {}
-    public ImapCommandResult MoveTryCreateMailbox(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
-    public ImapCommandResult MoveTryCreateMailbox(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
+    public ImapCommandResult Move(IImapNumberSet sequenceOrUidSet, ImapMailboxStatus mailbox) {}
+    public ImapCommandResult Move(IImapNumberSet sequenceOrUidSet, ImapMailboxStatus mailbox, out ImapCopiedUidSet copiedUids) {}
+    public ImapCommandResult Move(IImapNumberSet sequenceOrUidSet, string mailboxName) {}
+    public ImapCommandResult Move(IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids) {}
+    public ImapCommandResult MoveTryCreateMailbox(IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
+    public ImapCommandResult MoveTryCreateMailbox(IImapNumberSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
     public ImapCommandResult Namespace() {}
     public ImapCommandResult Namespace(out ImapNamespace namespaces) {}
     public ImapCommandResult NoOp() {}
     public ImapCommandResult RList(string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult RList(string referenceName, string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult RListAll(out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult RLsub(string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult RLsub(string referenceName, string mailboxName, out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult RLsubAll(out IReadOnlyList<ImapMailboxStatus> mailboxes) {}
     public ImapCommandResult Rename(ImapMailboxStatus existingMailbox, string newMailboxName) {}
     public ImapCommandResult Rename(ImapMailboxStatus existingMailbox, string newMailboxName, out ImapMailboxStatus renamedMailbox) {}
     public ImapCommandResult Rename(string existingMailboxName, string newMailboxName) {}
     public ImapCommandResult Rename(string existingMailboxName, string newMailboxName, out ImapMailboxStatus renamedMailbox) {}
     public ImapCommandResult Search(out ImapMatchedSequenceSet matched, ImapSearchCriteria searchingCriteria, Encoding charset = null) {}
     public ImapCommandResult Select(ImapMailboxStatus mailbox) {}
     public ImapCommandResult Select(string mailboxName) {}
     public ImapCommandResult SelectCondStore(ImapMailboxStatus mailbox) {}
     public ImapCommandResult SelectCondStore(string mailboxName) {}
     public ImapCommandResult SetMetadata(ImapMailboxStatus mailbox, params ImapMetadata[] metadata) {}
     public ImapCommandResult SetMetadata(string mailboxName, params ImapMetadata[] metadata) {}
     public ImapCommandResult SetMetadataRemoval(ImapMailboxStatus mailbox, params string[] entrySpecifiers) {}
     public ImapCommandResult SetMetadataRemoval(string mailboxName, params string[] entrySpecifiers) {}
     public ImapCommandResult SetMetadataServer(params ImapMetadata[] metadata) {}
     public ImapCommandResult SetMetadataServerRemoval(string[] entrySpecifiers) {}
-    public ImapCommandResult SetQuota(string quotaRoot, IReadOnlyCollection<ImapQuotaResource> resourceLimits) {}
-    public ImapCommandResult SetQuota(string quotaRoot, IReadOnlyCollection<ImapQuotaResource> resourceLimits, out ImapQuota changedQuota) {}
-    public ImapCommandResult SetQuota(string quotaRoot, ImapQuotaResource resourceLimit) {}
-    public ImapCommandResult SetQuota(string quotaRoot, ImapQuotaResource resourceLimit, out ImapQuota changedQuota) {}
+    public ImapCommandResult SetQuota(string quotaRoot, IReadOnlyCollection<ImapQuotaResourceLimit> resourceLimits) {}
+    public ImapCommandResult SetQuota(string quotaRoot, IReadOnlyCollection<ImapQuotaResourceLimit> resourceLimits, out ImapQuota changedQuota) {}
+    public ImapCommandResult SetQuota(string quotaRoot, ImapQuotaResourceLimit resourceLimit) {}
+    public ImapCommandResult SetQuota(string quotaRoot, ImapQuotaResourceLimit resourceLimit, out ImapQuota changedQuota) {}
     public ImapCommandResult SetQuota(string quotaRoot, string resourceName, long resourceLimit) {}
     public ImapCommandResult SetQuota(string quotaRoot, string resourceName, long resourceLimit, out ImapQuota changedQuota) {}
     public ImapCommandResult Sort(out ImapMatchedSequenceSet matched, ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, Encoding charset = null) {}
     public ImapCommandResult StartTls(UpgradeConnectionStreamCallback createAuthenticatedStream, bool reissueCapability = false) {}
     public ImapCommandResult Status(ImapMailboxStatus mailbox, ImapStatusDataItems statusDataItems) {}
-    public ImapCommandResult Status(ImapMailboxStatus mailbox, ImapStatusDataItems statusDataItems, out ImapStatusAttributes statusAttributes) {}
     public ImapCommandResult Status(string mailboxName, ImapStatusDataItems statusDataItems) {}
-    public ImapCommandResult Status(string mailboxName, ImapStatusDataItems statusDataItems, out ImapStatusAttributes statusAttributes) {}
-    public ImapCommandResult Status(string mailboxName, ImapStatusDataItems statusDataItems, out ImapStatusAttributes statusAttributes, out ImapMailboxStatus statusMailbox) {}
-    public ImapCommandResult Store(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems) {}
-    public ImapCommandResult Store(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, out ImapMessageDynamicAttributes[] messageAttributes) {}
-    public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq) {}
-    public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq, out ImapMessageDynamicAttributes[] messageAttributes) {}
-    public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq, out ImapMessageDynamicAttributes[] messageAttributes, out ImapSequenceSet failedMessageSet) {}
-    public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq, out ImapSequenceSet failedMessageSet) {}
+    public ImapCommandResult Status(string mailboxName, ImapStatusDataItems statusDataItems, out ImapMailboxStatus statusMailbox) {}
+    public ImapCommandResult Store(IImapNumberSet sequenceOrUidSet, ImapStoreDataItems storeDataItems) {}
+    public ImapCommandResult Store(IImapNumberSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, out ImapMessageDynamicAttributes[] messageAttributes) {}
+    public ImapCommandResult StoreUnchangedSince(IImapNumberSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq) {}
+    public ImapCommandResult StoreUnchangedSince(IImapNumberSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq, out IImapNumberSet failedMessageSet) {}
+    public ImapCommandResult StoreUnchangedSince(IImapNumberSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq, out ImapMessageDynamicAttributes[] messageAttributes) {}
+    public ImapCommandResult StoreUnchangedSince(IImapNumberSet sequenceOrUidSet, ImapStoreDataItems storeDataItems, ulong modSeq, out ImapMessageDynamicAttributes[] messageAttributes, out IImapNumberSet failedMessageSet) {}
     public ImapCommandResult Subscribe(ImapMailboxStatus mailbox) {}
     public ImapCommandResult Subscribe(string mailboxName) {}
-    void IDisposable.Dispose() {}
     public ImapCommandResult Thread(out ImapThreadList threadList, ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, Encoding charset = null) {}
     public override string ToString() {}
     public ImapCommandResult UidESearch(out ImapMatchedSequenceSet matched, ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, Encoding charset = null) {}
     public ImapCommandResult UidESort(out ImapMatchedSequenceSet matched, ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, Encoding charset = null) {}
-    public ImapCommandResult UidExpunge(ImapSequenceSet uidSet) {}
-    public ImapCommandResult UidExpunge(ImapSequenceSet uidSet, out IReadOnlyList<long> expungedMessages) {}
+    public ImapCommandResult UidExpunge(IImapNumberSet uidSet) {}
+    public ImapCommandResult UidExpunge(IImapNumberSet uidSet, out IReadOnlyList<long> expungedMessages) {}
     public ImapCommandResult UidSearch(out ImapMatchedSequenceSet matched, ImapSearchCriteria searchingCriteria, Encoding charset = null) {}
     public ImapCommandResult UidSort(out ImapMatchedSequenceSet matched, ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, Encoding charset = null) {}
     public ImapCommandResult UidThread(out ImapThreadList threadList, ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, Encoding charset = null) {}
     public ImapCommandResult Unselect() {}
     public ImapCommandResult Unsubscribe(ImapMailboxStatus mailbox) {}
     public ImapCommandResult Unsubscribe(string mailboxName) {}
   }
-
-  public static class ImapSessionCreator {
-    public static ImapCommandResult CreateSession(out ImapSession session, IImapSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
-    public static ImapSession CreateSession(IImapSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
-  }
 }
 
 namespace Smdn.Net.Imap4.Protocol.Strings {
   [Flags]
   public enum ImapLiteralOptions : int {
     Default = 0x00000002,
     Literal = 0x00000000,
     Literal8 = 0x00000010,
     Literal8IfCapable = 0x00000020,
     LiteralMode = 0x000000f0,
     NonSynchronizing = 0x00000001,
     NonSynchronizingIfCapable = 0x00000002,
     SynchronizationMode = 0x0000000f,
     Synchronizing = 0x00000000,
   }
 
+  [Serializable]
+  public abstract class ImapEnumValue :
+    ImapString,
+    IEquatable<string>
+  {
+    public string Value { get; }
+
+    public bool Equals(string other) {}
+    public override bool Equals(object obj) {}
+    public override int GetHashCode() {}
+    public override string ToString() {}
+  }
+
   public abstract class ImapLiteralString : ImapString {
     protected ImapLiteralString(ImapLiteralOptions options) {}
 
     internal protected abstract long Length { get; }
 
     public static ImapLiteralString Create(string @value, Encoding charset, ImapLiteralOptions options = ImapLiteralOptions.Default) {}
     internal protected abstract Stream GetStream();
     protected virtual string GetValueString() {}
     public override string ToString() {}
   }
 
   public static class ImapNilString {
     public static readonly ImapString Nil; // = "NIL"
   }
 
   public static class ImapQuotedString {
     public static readonly ImapString Empty; // = "\"\""
 
     public static ImapString Create(string @value) {}
   }
 
   [Serializable]
-  public abstract class ImapString :
-    IEquatable<ImapString>,
-    IEquatable<string>
-  {
+  public abstract class ImapString {
     protected ImapString() {}
 
-    public override bool Equals(object obj) {}
-    public virtual bool Equals(ImapString other) {}
-    public virtual bool Equals(string other) {}
-    public override int GetHashCode() {}
     public override string ToString() {}
     public static implicit operator ImapString(string str) {}
   }
 
-  [Serializable]
-  public abstract class ImapStringEnum :
-    ImapString,
-    IStringEnum
-  {
-    protected ImapStringEnum(string @value) {}
-
-    public string Value { get; }
-
-    public bool Equals(IStringEnum other) {}
-    public override bool Equals(object obj) {}
-    public override bool Equals(string other) {}
-    public override int GetHashCode() {}
-    public override string ToString() {}
-  }
-
   public class ImapStringList :
     ImapString,
     IReadOnlyCollection<ImapString>
   {
     int IReadOnlyCollection<ImapString>.Count { get; }
 
     public static ImapStringList Create(IReadOnlyCollection<ImapString> values) {}
     public static ImapStringList Create(IReadOnlyCollection<string> values) {}
     public static ImapStringList Create(string @value) {}
     public static ImapStringList CreateParenthesized(IReadOnlyCollection<ImapString> values) {}
     public static ImapStringList CreateParenthesized(IReadOnlyCollection<string> values) {}
     public static ImapStringList CreateParenthesized(string @value) {}
     public IEnumerator<ImapString> GetEnumerator() {}
     IEnumerator IEnumerable.GetEnumerator() {}
     public override string ToString() {}
   }
 }
 
 namespace Smdn.Net.Imap4.Protocol.Transmission {
   public enum ImapDataFormat : int {
     List = 2,
     Nil = 3,
     Text = 1,
     Undefined = 0,
   }
 
   public enum ImapResponseCondition : int {
     Bad = -2,
     Bye = -3,
     No = -1,
     Ok = 1,
     PreAuth = 2,
     Undefined = 0,
   }
 
   public sealed class ImapCommand {
     public IReadOnlyList<ImapString> Arguments { get; }
     public string Command { get; }
     public string Tag { get; }
 
     public static ImapCommand Create(string command, string tag, params ImapString[] arguments) {}
     public static ImapCommand CreateContinuation(ImapString argument) {}
     public override string ToString() {}
   }
 
   [Serializable]
   public sealed class ImapCommandContinuationRequest : ImapResponse {
     public ImapResponseText ResponseText { get; }
     public ByteString Text { get; }
 
     public override string ToString() {}
   }
 
   [Serializable]
   public class ImapCommandResult : ISerializable {
     internal protected ImapCommandResult(SerializationInfo info, StreamingContext context) {}
 
     public string Description { get; }
     public ImapStatusResponse FinalStatusResponse { get; }
     public virtual bool IsConcludedByClientSide { get; }
     public virtual bool IsSuccess { get; }
     public IReadOnlyList<ImapResponse> ReceivedResponses { get; }
     public ImapTaggedStatusResponse TaggedStatusResponse { get; }
 
     public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
     public ImapStatusResponse GetStatusResponseOfCode(ImapResponseCode code) {}
     public bool IsFinalResponseCondition(ImapResponseCondition condition) {}
     public override string ToString() {}
   }
 
   public sealed class ImapCommandSender : ImapSender {
     public ImapCommandSender(LineOrientedBufferedStream stream) {}
 
     public bool IsCommandContinuing { get; }
 
     public void Send(ImapCommand command) {}
     public void SendRemainder() {}
   }
 
   public sealed class ImapConnection : ConnectionBase {
     public class CommandContinuationContext {
     }
 
-    public ImapConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStream) {}
+    public ImapConnection() {}
 
+    public static TraceSource ConnectionTraceSource { get; }
     public bool IsIdling { get; }
-    public static TraceSource TraceSource { get; }
+    protected override TraceSource TraceSource { get; }
 
-    protected override LineOrientedBufferedStream CreateBufferedStream(Stream stream) {}
-    protected override Exception CreateConnectException(string message, Exception innerException) {}
-    protected override Exception CreateUpgradeStreamException(string message, Exception innerException) {}
+    protected override Exception CreateConnectException(string message, Exception baseException) {}
+    protected override Exception CreateUpgradeConnectionException(string message, Exception baseException) {}
+    protected override Exception CreateUpgradeToSecureConnectionException(string message, Exception baseException) {}
+    protected override int GetDefaultPort(bool asSecurePortConnection) {}
+    protected override void OnConnectionStreamChanged(Stream stream) {}
     public ImapConnection.CommandContinuationContext SendCommand(ImapCommand command) {}
     public ImapConnection.CommandContinuationContext SendCommand(ImapConnection.CommandContinuationContext context) {}
     public ImapResponse TryReceiveResponse() {}
   }
 
   [Serializable]
   public abstract class ImapData : ISerializable {
     public abstract ImapDataFormat Format { get; }
     public virtual IReadOnlyList<ImapData> List { get; }
 
     public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
     public virtual ByteString GetTextAsByteString() {}
     public virtual string GetTextAsString() {}
     public virtual long GetTextLength() {}
     public virtual void ReadText(Action<Stream> read) {}
   }
 
   public static class ImapDataParser {
     public static bool IsTextEqualsToCaseInsensitive(ImapData data, string text) {}
     public static string ToAString(ImapData astring) {}
     public static ImapAddress ToAddress(ImapData address) {}
     public static IImapBodyStructure ToBody(ImapData body) {}
     public static IReadOnlyStringSet<ImapCapability> ToCapability(IReadOnlyList<ImapData> list) {}
     public static ImapCapability ToCapability(ImapData capability) {}
     public static ImapCollationAlgorithm ToCompOrderQuoted(ImapData compOrderQuoted) {}
     public static ImapCollationAlgorithm ToCompSelQuoted(ImapData compSelQuoted) {}
     public static DateTimeOffset ToDateTime(ImapData dateTime) {}
     public static IReadOnlyList<string> ToEntryList(IReadOnlyList<ImapData> entryList) {}
     public static IReadOnlyList<ImapMetadata> ToEntryValues(ImapData entryValues) {}
     public static ImapEnvelope ToEnvelope(ImapData envelope) {}
     public static bool ToFetchMessageData<TMessageAttributes>(IImapMessageAttributeCollection<TMessageAttributes> messages, bool updateOnly, ImapData nzNumber, ImapData msgAtt, out TMessageAttributes message) where TMessageAttributes : ImapMessageAttributesBase {}
     public static void ToFetchMessageData<TMessageAttributes>(ref TMessageAttributes attributes, ImapData nzNumber, ImapData msgAtt) where TMessageAttributes : ImapMessageAttributesBase {}
     public static IReadOnlyStringSet<ImapMessageFlag> ToFlagFetch(IReadOnlyList<ImapData> flags) {}
     public static IReadOnlyStringSet<ImapMessageFlag> ToFlagList(ImapData flagList) {}
     public static IReadOnlyStringSet<ImapMessageFlag> ToFlagPerm(IReadOnlyList<ImapData> flags) {}
     public static IReadOnlyStringSet<ImapMessageFlag> ToFlags(IReadOnlyList<ImapData> flags) {}
     public static IReadOnlyDictionary<string, string> ToIdParamsList(ImapData idParamsList) {}
     public static string ToLangTagQuoted(ImapData langTagQuoted) {}
     public static string ToMailbox(ImapData data) {}
     public static ImapListedMailbox ToMailboxList(IReadOnlyList<ImapData> mailboxList) {}
     public static IReadOnlyDictionary<string, ImapData> ToMboxListExtended(ImapData mboxListExtended) {}
     public static IReadOnlyStringSet<ImapMailboxFlag> ToMbxListFlags(IReadOnlyList<ImapData> list) {}
     public static ulong ToModSequenceValue(ImapData modSequenceValue) {}
     public static ulong ToModSequenceValzer(ImapData modSequenceValzer) {}
     public static bool ToMsgAtt(ImapMessageAttributesBase attributes, ImapData msgAtt) {}
     public static string ToNString(ImapData nstring) {}
     public static IReadOnlyList<ImapNamespaceDesc> ToNamespace(ImapData @namespace) {}
     public static long ToNonZeroNumber(ImapData nzNumber) {}
     public static long ToNumber(ImapData number) {}
-    public static IReadOnlyList<ImapQuotaResource> ToQuotaList(ImapData quotaList) {}
+    public static IReadOnlyList<ImapQuotaResourceUsage> ToQuotaList(ImapData quotaList) {}
     public static string ToSearchCorrelator(ImapData searchCorrelator) {}
     public static ImapMatchedSequenceSet ToSearchReturnData(IReadOnlyList<ImapData> searchReturnData, string tag, bool uid, int startIndex) {}
-    public static ImapSequenceSet ToSequenceOrUidSet(bool uid, ImapData sequenceSet) {}
-    public static ImapStatusAttributes ToStatusAttList(IReadOnlyList<ImapData> statusAttList) {}
+    public static IImapNumberSet ToSequenceOrUidSet(bool uid, ImapData sequenceSet) {}
+    public static void ToStatusAttList(ImapData statusAttList, Action<string, ImapData> updateMailboxStatus) {}
     public static string ToString(ImapData @string) {}
     public static IReadOnlyList<ImapThreadList> ToThreadList(bool uid, ImapData threadList) {}
     public static ImapThreadList ToThreadList(bool uid, IReadOnlyList<ImapData> threadLists) {}
     public static ImapThreadList ToThreadMembers(bool uid, IReadOnlyList<ImapData> threadMembers) {}
     public static IReadOnlyList<ImapThreadList> ToThreadNested(bool uid, IReadOnlyList<ImapData> list) {}
     public static long ToUniqueId(ImapData uniqueId) {}
     public static Uri ToUri(ImapData uri) {}
   }
 
   public class ImapDeflateStream : Stream {
     public ImapDeflateStream(Stream innerStream) {}
 
     public override bool CanRead { get; }
     public override bool CanSeek { get; }
     public override bool CanTimeout { get; }
     public override bool CanWrite { get; }
     public Stream InnerStream { get; }
     public override long Length { get; }
     public override long Position { get; set; }
 
     protected override void Dispose(bool disposing) {}
     public override void Flush() {}
     public override int Read(byte[] buffer, int offset, int count) {}
     public override long Seek(long offset, SeekOrigin origin) {}
     public override void SetLength(long @value) {}
     public override void Write(byte[] buffer, int offset, int count) {}
   }
 
   [Serializable]
   public abstract class ImapFormatException : FormatException {
     protected ImapFormatException() {}
     protected ImapFormatException(SerializationInfo info, StreamingContext context) {}
     protected ImapFormatException(string message) {}
     protected ImapFormatException(string message, Exception innerException) {}
   }
 
   [Serializable]
   public class ImapMalformedDataException : ImapFormatException {
     protected ImapMalformedDataException(SerializationInfo info, StreamingContext context) {}
     public ImapMalformedDataException() {}
     public ImapMalformedDataException(ImapData causedData) {}
     public ImapMalformedDataException(string message) {}
     public ImapMalformedDataException(string message, ImapData causedData) {}
 
     public ImapData CausedData { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public class ImapMalformedResponseException : ImapFormatException {
     protected ImapMalformedResponseException(SerializationInfo info, StreamingContext context) {}
     public ImapMalformedResponseException() {}
     public ImapMalformedResponseException(string message) {}
     public ImapMalformedResponseException(string message, Exception innerException) {}
     public ImapMalformedResponseException(string message, string causedResponse) {}
 
     public string CausedResponse { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   public abstract class ImapReceiver {
     protected sealed class ParsingContext {
     }
 
     protected ImapReceiver(LineOrientedBufferedStream stream) {}
 
     protected IReadOnlyList<ImapData> ParseData(ByteString line, int offset, int indexOfEOL, ref ImapReceiver.ParsingContext context) {}
     protected IReadOnlyList<ImapData> ParseData(ByteString text, int offset) {}
     protected ByteString Receive() {}
   }
 
   [Serializable]
   public abstract class ImapResponse {
   }
 
   public sealed class ImapResponseReceiver : ImapReceiver {
     public ImapResponseReceiver(LineOrientedBufferedStream stream) {}
 
     public bool IsResponseContinuing { get; }
     public bool ReceiveResponseAsUTF8 { get; set; }
 
     public ImapResponse ReceiveResponse() {}
   }
 
   [Serializable]
   public sealed class ImapResponseText {
     public IReadOnlyList<ImapData> Arguments { get; }
     public ImapResponseCode Code { get; }
     public string Text { get; }
 
     public override string ToString() {}
   }
 
   public static class ImapResponseTextParser {
     public static ImapAppendedUidSet FromAppendUid(ImapResponseText respText) {}
     public static IReadOnlyList<string> FromBadCharset(ImapResponseText respText) {}
     public static IReadOnlyStringSet<ImapCapability> FromCapability(ImapResponseText respText) {}
     public static ImapCopiedUidSet FromCopyUid(ImapResponseText respText) {}
     public static ulong FromHighestModSeq(ImapResponseText respText) {}
     public static long FromMetadataLongEntries(ImapResponseText respText) {}
     public static long FromMetadataMaxSize(ImapResponseText respText) {}
-    public static ImapSequenceSet FromModified(ImapResponseText respText, bool uid) {}
+    public static IImapNumberSet FromModified(ImapResponseText respText, bool uid) {}
     public static IReadOnlyStringSet<ImapMessageFlag> FromPermanentFlags(ImapResponseText respText) {}
     public static IReadOnlyList<Uri> FromReferral(ImapResponseText respText) {}
     public static long FromUidNext(ImapResponseText respText) {}
     public static long FromUidValidity(ImapResponseText respText) {}
     public static string FromUndefinedFilter(ImapResponseText respText) {}
     public static long FromUnseen(ImapResponseText respText) {}
   }
 
   public abstract class ImapSender {
     protected ImapSender(LineOrientedBufferedStream stream) {}
 
     internal protected int UnsentFragmentCount { get; }
 
     protected void ClearUnsent() {}
     protected void Enqueue(bool terminateByCrLf, IEnumerable<ImapString> args) {}
     protected void Send() {}
   }
 
   [Serializable]
   public class ImapServerDataResponse : ImapResponse {
     public IReadOnlyList<ImapData> DataList { get; }
     public virtual ImapData SizeStatusNumber { get; }
     public ImapServerDataResponseType Type { get; }
 
     public override string ToString() {}
   }
 
   public static class ImapServerDataResponseParser {
     public static IReadOnlyStringSet<ImapCapability> FromCapability(ImapServerDataResponse data) {}
     public static ImapCollationAlgorithm FromComparator(ImapServerDataResponse data, out IReadOnlyList<ImapCollationAlgorithm> matchingComparators) {}
     public static ImapMatchedSequenceSet FromESearch(ImapServerDataResponse data) {}
     public static IReadOnlyStringSet<ImapCapability> FromEnabled(ImapServerDataResponse data) {}
     public static long FromExists(ImapServerDataResponse data) {}
     public static long FromExpunge(ImapServerDataResponse data) {}
     public static TMessageAttributes FromFetch<TMessageAttributes>(ImapServerDataResponse data) where TMessageAttributes : ImapMessageAttributesBase {}
     public static bool FromFetch<TMessageAttributes>(IImapMessageAttributeCollection<TMessageAttributes> messages, bool updateOnly, ImapServerDataResponse data, out TMessageAttributes message) where TMessageAttributes : ImapMessageAttributesBase {}
     public static IReadOnlyStringSet<ImapMessageFlag> FromFlags(ImapServerDataResponse data) {}
     public static IReadOnlyDictionary<string, string> FromId(ImapServerDataResponse data) {}
     public static IReadOnlyList<string> FromLanguage(ImapServerDataResponse data) {}
     public static ImapListedMailbox FromList(ImapServerDataResponse data) {}
     public static ImapListedMailbox FromListLsub(ImapServerDataResponse data) {}
     public static ImapListedMailbox FromLsub(ImapServerDataResponse data) {}
     public static IReadOnlyList<string> FromMetadataEntryList(ImapServerDataResponse data, out string mailbox) {}
     public static IReadOnlyList<ImapMetadata> FromMetadataEntryValues(ImapServerDataResponse data, out string mailbox) {}
     public static ImapNamespace FromNamespace(ImapServerDataResponse data) {}
     public static ImapQuota FromQuota(ImapServerDataResponse data) {}
     public static string FromQuotaRoot(ImapServerDataResponse data, out IReadOnlyList<string> quotaRootNames) {}
     public static long FromRecent(ImapServerDataResponse data) {}
     public static ImapMatchedSequenceSet FromSearch(ImapServerDataResponse data, bool uidSet) {}
     public static ImapMatchedSequenceSet FromSort(ImapServerDataResponse data, bool uidSet) {}
-    public static ImapStatusAttributes FromStatus(ImapServerDataResponse data) {}
-    public static ImapStatusAttributes FromStatus(ImapServerDataResponse data, out string mailbox) {}
+    public static (string mailbox, IReadOnlyDictionary<string, ImapData> statusAttributes) FromStatus(ImapServerDataResponse data) {}
     public static ImapThreadList FromThread(ImapServerDataResponse data, bool uidSet) {}
   }
 
   [Serializable]
   public abstract class ImapStatusResponse : ImapResponse {
     public ImapResponseCondition Condition { get; }
     public abstract bool IsTaggedResponse { get; }
     public ImapResponseText ResponseText { get; }
 
     public override string ToString() {}
   }
 
   [Serializable]
   public sealed class ImapTaggedStatusResponse : ImapStatusResponse {
     public override bool IsTaggedResponse { get; }
     public string Tag { get; }
 
     public override string ToString() {}
   }
 
   [Serializable]
   public class ImapUnexpectedResponseException : ImapInvalidOperationException {
     protected ImapUnexpectedResponseException(SerializationInfo info, StreamingContext context) {}
     public ImapUnexpectedResponseException() {}
     public ImapUnexpectedResponseException(string message) {}
     public ImapUnexpectedResponseException(string message, ImapResponse unexpectedResponse) {}
 
     public ImapResponse CausedResponse { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public sealed class ImapUntaggedStatusResponse : ImapStatusResponse {
     public override bool IsTaggedResponse { get; }
   }
 }
 
 namespace Smdn.Net.Imap4.Urls {
   public interface IImapUrl {
     Uri Url { get; }
 
     void SetBaseUrl(ImapUriBuilder baseUrl);
   }
 
   public interface IImapUrlSearchQuery {
     byte[] GetEncodedQuery(Encoding charset, out bool charsetSpecified);
   }
 
   public enum ImapUriForm : int {
     FetchMessage = 3,
     ListMessages = 1,
     Relative = 4,
     SearchMessages = 2,
     Server = 0,
     Unknown = 5,
   }
 
   public class ImapStyleUriParser : GenericUriParser {
     public ImapStyleUriParser() {}
 
     public static ImapAuthenticationMechanism GetAuthType(Uri uri) {}
     public static string GetAuthority(Uri uri) {}
     public static string GetMailbox(Uri uri) {}
-    public static ImapFetchRange? GetPartial(Uri uri) {}
+    public static ImapFetchRange GetPartial(Uri uri) {}
     public static string GetSection(Uri uri) {}
     public static string GetStrongAuthority(Uri uri) {}
     public static long GetUid(Uri uri) {}
     public static long GetUidValidity(Uri uri) {}
     public static ImapUriForm GetUriForm(Uri uri) {}
     public static string GetUser(Uri uri) {}
     protected override void InitializeAndValidate(Uri uri, out UriFormatException parsingError) {}
   }
 
   public static class ImapUri {
     public static readonly string UriSchemeImap = "imap";
     public static readonly string UriSchemeImaps = "imaps";
 
     public static int GetDefaultPortFromScheme(Uri uri) {}
     public static int GetDefaultPortFromScheme(string scheme) {}
     public static bool IsImap(Uri uri) {}
     public static void RegisterParser() {}
   }
 
   public class ImapUriBuilder :
     ICloneable,
     IEquatable<ImapUriBuilder>,
     IEquatable<Uri>
   {
     public ImapUriBuilder() {}
     public ImapUriBuilder(Uri baseUri, string mailbox) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, IImapUrlSearchQuery searchCriteria) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, IImapUrlSearchQuery searchCriteria, Encoding charset) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, long uid, string section) {}
-    public ImapUriBuilder(Uri baseUri, string mailbox, long uid, string section, ImapFetchRange? @partial) {}
+    public ImapUriBuilder(Uri baseUri, string mailbox, long uid, string section, ImapFetchRange @partial) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, long uidValidity) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, long uidValidity, IImapUrlSearchQuery searchCriteria) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, long uidValidity, IImapUrlSearchQuery searchCriteria, Encoding charset) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, long uidValidity, long uid) {}
     public ImapUriBuilder(Uri baseUri, string mailbox, long uidValidity, long uid, string section) {}
-    public ImapUriBuilder(Uri baseUri, string mailbox, long uidValidity, long uid, string section, ImapFetchRange? @partial) {}
+    public ImapUriBuilder(Uri baseUri, string mailbox, long uidValidity, long uid, string section, ImapFetchRange @partial) {}
     public ImapUriBuilder(Uri uri) {}
     public ImapUriBuilder(Uri uri, Converter<Uri, IImapUrlSearchQuery> parseQuery) {}
     public ImapUriBuilder(bool imapsScheme, string host) {}
     public ImapUriBuilder(bool imapsScheme, string host, int port) {}
     public ImapUriBuilder(bool imapsScheme, string host, int port, string userName, ImapAuthenticationMechanism authType) {}
     public ImapUriBuilder(bool imapsScheme, string host, string userName, ImapAuthenticationMechanism authType) {}
     public ImapUriBuilder(string baseUri, string mailbox) {}
     public ImapUriBuilder(string baseUri, string mailbox, IImapUrlSearchQuery searchCriteria) {}
     public ImapUriBuilder(string baseUri, string mailbox, IImapUrlSearchQuery searchCriteria, Encoding charset) {}
     public ImapUriBuilder(string baseUri, string mailbox, long uid, string section) {}
-    public ImapUriBuilder(string baseUri, string mailbox, long uid, string section, ImapFetchRange? @partial) {}
+    public ImapUriBuilder(string baseUri, string mailbox, long uid, string section, ImapFetchRange @partial) {}
     public ImapUriBuilder(string baseUri, string mailbox, long uidValidity) {}
     public ImapUriBuilder(string baseUri, string mailbox, long uidValidity, IImapUrlSearchQuery searchCriteria) {}
     public ImapUriBuilder(string baseUri, string mailbox, long uidValidity, IImapUrlSearchQuery searchCriteria, Encoding charset) {}
     public ImapUriBuilder(string baseUri, string mailbox, long uidValidity, long uid) {}
     public ImapUriBuilder(string baseUri, string mailbox, long uidValidity, long uid, string section) {}
-    public ImapUriBuilder(string baseUri, string mailbox, long uidValidity, long uid, string section, ImapFetchRange? @partial) {}
+    public ImapUriBuilder(string baseUri, string mailbox, long uidValidity, long uid, string section, ImapFetchRange @partial) {}
     public ImapUriBuilder(string host, int port) {}
     public ImapUriBuilder(string host, int port, string userName, ImapAuthenticationMechanism authType) {}
     public ImapUriBuilder(string host, string userName, ImapAuthenticationMechanism authType) {}
     public ImapUriBuilder(string uri) {}
     public ImapUriBuilder(string uri, Converter<Uri, IImapUrlSearchQuery> parseQuery) {}
 
     public ImapAuthenticationMechanism AuthType { get; set; }
     public Encoding Charset { get; set; }
     public string Host { get; set; }
     public string Mailbox { get; set; }
-    public ImapFetchRange? Partial { get; set; }
+    public ImapFetchRange Partial { get; set; }
     public int Port { get; set; }
     public string Scheme { get; set; }
     public IImapUrlSearchQuery SearchCriteria { get; set; }
     public string Section { get; set; }
     public long Uid { get; set; }
     public long UidValidity { get; set; }
     public Uri Uri { get; }
     public string UserName { get; set; }
 
     public ImapUriBuilder Clone() {}
     public bool Equals(ImapUriBuilder other) {}
     public bool Equals(Uri other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     object ICloneable.Clone() {}
     public override string ToString() {}
   }
 }