1.91-netstandard2.0_vs_2.0alpha1-netstandard2.0.apilist.diff
--- Smdn.Net.Pop3.Client-1.91-netstandard2.0.apilist.cs	2019-01-30 03:03:34.438020354 +0900
+++ Smdn.Net.Pop3.Client-2.0alpha1-netstandard2.0.apilist.cs	2019-01-30 03:03:37.221974490 +0900
@@ -1,1001 +1,936 @@
-// Smdn.Net.Pop3.Client-1.91 (netstandard2.0)
+// Smdn.Net.Pop3.Client-2.0alpha1 (netstandard2.0)
 //   Name: Smdn.Net.Pop3.Client
 //   TargetFramework: .NETStandard,Version=v2.0
-//   AssemblyVersion: 1.91.0.0
-//   InformationalVersion: 1.91 (netstandard2.0)
+//   AssemblyVersion: 2.0.0.0
+//   InformationalVersion: 2.0alpha1 (netstandard2.0)
 
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Net;
 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.IO.Streams.LineOriented;
 using Smdn.Net.Connection;
 using Smdn.Net.MessageAccessProtocols;
 using Smdn.Net.Pop3;
 using Smdn.Net.Pop3.Client;
 using Smdn.Net.Pop3.Protocol;
 using Smdn.Net.Pop3.Protocol.DataStructures;
 using Smdn.Net.Pop3.Protocol.Session;
 using Smdn.Net.Pop3.Protocol.Strings;
 using Smdn.Net.Pop3.Protocol.Transmission;
 using Smdn.Net.Pop3.Urls;
 using Smdn.Security.Authentication.Sasl.Client;
 using Smdn.Text;
 
 namespace Smdn.Net.Pop3 {
   [Serializable]
   public class PopException : Exception {
     protected PopException(SerializationInfo info, StreamingContext context) {}
     public PopException() {}
     public PopException(string message) {}
     public PopException(string message, Exception innerException) {}
   }
 }
 
 namespace Smdn.Net.Pop3.Client {
   public class PopClient : IDisposable {
     public PopClient() {}
     public PopClient(PopClientProfile profile) {}
     public PopClient(Uri authority) {}
-    public PopClient(string host) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public PopClient(string host, bool securePort, string userName) {}
-    public PopClient(string host, int port) {}
-    public PopClient(string host, int port, bool securePort) {}
-    public PopClient(string host, int port, bool securePort, string userName) {}
-    public PopClient(string host, int port, bool securePort, string userName, string authType) {}
-    public PopClient(string host, int port, bool securePort, string userName, string authType, int timeout) {}
+    public PopClient(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, bool allowStandardLogin = true, bool allowAllowApopLogin = true) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public PopClient(string host, int port, string userName) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public PopClient(string host, int port, string userName, string authType) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public PopClient(string host, string userName) {}
 
     public bool DeleteAfterRetrieve { get; set; }
     public bool IsBusy { get; }
     public bool IsConnected { get; }
     public bool IsSecureSession { get; }
     public long MessageCount { get; }
     public PopClientProfile Profile { get; }
     public int ReceiveTimeout { get; set; }
     public int SendTimeout { get; set; }
-    public PopCapabilitySet ServerCapabilities { get; }
+    public IReadOnlyStringSet<PopCapability> ServerCapabilities { get; }
     public int Timeout { get; set; }
     public long TotalSize { get; }
 
-    public IAsyncResult BeginConnect(ICredentialsByHost credentials) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public IAsyncResult BeginConnect(ICredentialsByHost credentials, AsyncCallback asyncCallback, object asyncState) {}
-    public IAsyncResult BeginConnect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback) {}
-    public IAsyncResult BeginConnect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback, AsyncCallback asyncCallback, object asyncState) {}
-    public IAsyncResult BeginConnect(SaslClientMechanism authMechanism) {}
+    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 createSslStreamCallback) {}
-    public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback, AsyncCallback asyncCallback, object asyncState) {}
-    public IAsyncResult BeginConnect(string password) {}
+    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 createSslStreamCallback) {}
-    public IAsyncResult BeginConnect(string password, UpgradeConnectionStreamCallback createSslStreamCallback, AsyncCallback asyncCallback, object asyncState) {}
+    public IAsyncResult BeginConnect(string password, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
     public void CancelDelete() {}
     public Task CancelDeleteAsync() {}
-    public void Connect(ICredentialsByHost credentials) {}
-    public void Connect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback) {}
-    public void Connect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
-    public void Connect(SaslClientMechanism authMechanism) {}
-    public void Connect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback) {}
-    public void Connect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
-    public void Connect(string password) {}
-    public void Connect(string password, UpgradeConnectionStreamCallback createSslStreamCallback) {}
-    public void Connect(string password, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
-    public Task ConnectAsync(ICredentialsByHost credentials) {}
-    public Task ConnectAsync(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback) {}
-    public Task ConnectAsync(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
-    public Task ConnectAsync(SaslClientMechanism authMechanism) {}
-    public Task ConnectAsync(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback) {}
-    public Task ConnectAsync(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
-    public Task ConnectAsync(string password) {}
-    public Task ConnectAsync(string password, UpgradeConnectionStreamCallback createSslStreamCallback) {}
-    public Task ConnectAsync(string password, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
-    public void Disconnect() {}
-    public void Disconnect(bool logout) {}
-    public IEnumerable<TResult> DownloadAllMessagesAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
-    public IEnumerable<TResult> DownloadAllMessagesAs<TResult>(Converter<Stream, TResult> converter) {}
-    public static TResult[] DownloadAllMessagesAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
-    public static TResult[] DownloadAllMessagesAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
+    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 void Disconnect(bool logout = false) {}
+    public IReadOnlyList<TResult> DownloadAllMessagesAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
+    public IReadOnlyList<TResult> DownloadAllMessagesAs<TResult>(Converter<Stream, TResult> converter) {}
+    public static IReadOnlyList<TResult> DownloadAllMessagesAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
+    public static IReadOnlyList<TResult> DownloadAllMessagesAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
     public Task<IReadOnlyList<TResult>> DownloadAllMessagesAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
     public Task<IReadOnlyList<TResult>> DownloadAllMessagesAsAsync<TResult>(Converter<Stream, TResult> converter) {}
-    public IEnumerable<string> DownloadAllMessagesAsText(Encoding encoding) {}
-    public static string[] DownloadAllMessagesAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
+    public IReadOnlyList<string> DownloadAllMessagesAsText(Encoding encoding) {}
+    public static IReadOnlyList<string> DownloadAllMessagesAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
     public Task<IReadOnlyList<string>> DownloadAllMessagesAsTextAsync(Encoding encoding) {}
-    public FileInfo[] DownloadAllMessagesToDirectory(string directory) {}
-    public static FileInfo[] DownloadAllMessagesToDirectory(Uri popUrl, string password, bool deleteAfterDownload, string directory) {}
+    public IReadOnlyList<FileInfo> DownloadAllMessagesToDirectory(string directory) {}
+    public static IReadOnlyList<FileInfo> DownloadAllMessagesToDirectory(Uri popUrl, string password, bool deleteAfterDownload, string directory) {}
     public Task<IReadOnlyList<FileInfo>> DownloadAllMessagesToDirectoryAsync(string directory) {}
-    public FileInfo[] DownloadAllMessagesToFiles(Func<PopMessage, string> selectFileName) {}
-    public static FileInfo[] DownloadAllMessagesToFiles(Uri popUrl, string password, bool deleteAfterDownload, Func<PopMessage, string> selectFileName) {}
+    public IReadOnlyList<FileInfo> DownloadAllMessagesToFiles(Func<PopMessage, string> selectFileName) {}
+    public static IReadOnlyList<FileInfo> DownloadAllMessagesToFiles(Uri popUrl, string password, bool deleteAfterDownload, Func<PopMessage, string> selectFileName) {}
     public Task<IReadOnlyList<FileInfo>> DownloadAllMessagesToFilesAsync(Func<PopMessage, string> selectFileName) {}
     public TResult DownloadFirstMessageAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
     public TResult DownloadFirstMessageAs<TResult>(Converter<Stream, TResult> converter) {}
     public static TResult DownloadFirstMessageAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
     public static TResult DownloadFirstMessageAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
     public Task<TResult> DownloadFirstMessageAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
     public Task<TResult> DownloadFirstMessageAsAsync<TResult>(Converter<Stream, TResult> converter) {}
     public byte[] DownloadFirstMessageAsByteArray() {}
     public static byte[] DownloadFirstMessageAsByteArray(Uri popUrl, string password, bool deleteAfterDownload) {}
     public Task<byte[]> DownloadFirstMessageAsByteArrayAsync() {}
     public Stream DownloadFirstMessageAsStream() {}
     public static Stream DownloadFirstMessageAsStream(Uri popUrl, string password, bool deleteAfterDownload) {}
     public Task<Stream> DownloadFirstMessageAsStreamAsync() {}
     public static string DownloadFirstMessageAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
     public string DownloadFirstMessageAsText(Encoding encoding) {}
     public Task<string> DownloadFirstMessageAsTextAsync(Encoding encoding) {}
     public FileInfo DownloadFirstMessageToFile(string path) {}
     public static FileInfo DownloadFirstMessageToFile(Uri popUrl, string password, bool deleteAfterDownload, string path) {}
     public Task<FileInfo> DownloadFirstMessageToFileAsync(string path) {}
     public TResult DownloadLastMessageAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
     public TResult DownloadLastMessageAs<TResult>(Converter<Stream, TResult> converter) {}
     public static TResult DownloadLastMessageAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
     public static TResult DownloadLastMessageAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
     public Task<TResult> DownloadLastMessageAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
     public Task<TResult> DownloadLastMessageAsAsync<TResult>(Converter<Stream, TResult> converter) {}
     public byte[] DownloadLastMessageAsByteArray() {}
     public static byte[] DownloadLastMessageAsByteArray(Uri popUrl, string password, bool deleteAfterDownload) {}
     public Task<byte[]> DownloadLastMessageAsByteArrayAsync() {}
     public Stream DownloadLastMessageAsStream() {}
     public static Stream DownloadLastMessageAsStream(Uri popUrl, string password, bool deleteAfterDownload) {}
     public Task<Stream> DownloadLastMessageAsStreamAsync() {}
     public static string DownloadLastMessageAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
     public string DownloadLastMessageAsText(Encoding encoding) {}
     public Task<string> DownloadLastMessageAsTextAsync(Encoding encoding) {}
     public FileInfo DownloadLastMessageToFile(string path) {}
     public static FileInfo DownloadLastMessageToFile(Uri popUrl, string password, bool deleteAfterDownload, string path) {}
     public Task<FileInfo> DownloadLastMessageToFileAsync(string path) {}
     public TResult DownloadMessageAs<T, TResult>(long messageNumber, Func<Stream, T, TResult> read, T arg) {}
     public TResult DownloadMessageAs<TResult>(long messageNumber, Converter<Stream, TResult> converter) {}
     public Task<TResult> DownloadMessageAsAsync<T, TResult>(long messageNumber, Func<Stream, T, TResult> read, T arg) {}
     public Task<TResult> DownloadMessageAsAsync<TResult>(long messageNumber, Converter<Stream, TResult> converter) {}
     public byte[] DownloadMessageAsByteArray(long messageNumber) {}
     public Task<byte[]> DownloadMessageAsByteArrayAsync(long messageNumber) {}
     public Stream DownloadMessageAsStream(long messageNumber) {}
     public Task<Stream> DownloadMessageAsStreamAsync(long messageNumber) {}
     public string DownloadMessageAsText(long messageNumber, Encoding encoding) {}
     public Task<string> DownloadMessageAsTextAsync(long messageNumber, Encoding encoding) {}
     public FileInfo DownloadMessageToFile(long messageNumber, string path) {}
     public Task<FileInfo> DownloadMessageToFileAsync(long messageNumber, string path) {}
     public void EndConnect(IAsyncResult asyncResult) {}
-    public PopMessage GetFirstMessage() {}
-    public PopMessage GetFirstMessage(bool getUniqueId) {}
-    public Task<PopMessage> GetFirstMessageAsync() {}
+    public PopMessage GetFirstMessage(bool getUniqueId = false) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<PopMessage> GetFirstMessageAsync(CancellationToken cancellationToken) {}
-    public Task<PopMessage> GetFirstMessageAsync(bool getUniqueId) {}
-    public Task<PopMessage> GetFirstMessageAsync(bool getUniqueId, CancellationToken cancellationToken) {}
-    public PopMessage GetLastMessage() {}
-    public PopMessage GetLastMessage(bool getUniqueId) {}
-    public Task<PopMessage> GetLastMessageAsync() {}
+    public Task<PopMessage> GetFirstMessageAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
+    public PopMessage GetLastMessage(bool getUniqueId = false) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<PopMessage> GetLastMessageAsync(CancellationToken cancellationToken) {}
-    public Task<PopMessage> GetLastMessageAsync(bool getUniqueId) {}
-    public Task<PopMessage> GetLastMessageAsync(bool getUniqueId, CancellationToken cancellationToken) {}
-    public PopMessage GetMessage(long messageNumber) {}
-    public PopMessage GetMessage(long messageNumber, bool getUniqueId) {}
+    public Task<PopMessage> GetLastMessageAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
+    public PopMessage GetMessage(long messageNumber, bool getUniqueId = false) {}
     public PopMessage GetMessage(string uniqueId) {}
-    public Task<PopMessage> GetMessageAsync(long messageNumber) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<PopMessage> GetMessageAsync(long messageNumber, CancellationToken cancellationToken) {}
-    public Task<PopMessage> GetMessageAsync(long messageNumber, bool getUniqueId) {}
-    public Task<PopMessage> GetMessageAsync(long messageNumber, bool getUniqueId, CancellationToken cancellationToken) {}
-    public Task<PopMessage> GetMessageAsync(string uniqueId) {}
-    public Task<PopMessage> GetMessageAsync(string uniqueId, CancellationToken cancellationToken) {}
+    public Task<PopMessage> GetMessageAsync(long messageNumber, bool getUniqueId = false, CancellationToken cancellationToken = default) {}
+    public Task<PopMessage> GetMessageAsync(string uniqueId, CancellationToken cancellationToken = default) {}
     public static long GetMessageCount(Uri popUrl, string password) {}
-    public IEnumerable<PopMessage> GetMessages() {}
-    public IEnumerable<PopMessage> GetMessages(bool getUniqueId) {}
-    public Task<IReadOnlyList<PopMessage>> GetMessagesAsync() {}
+    public IReadOnlyList<PopMessage> GetMessages(bool getUniqueId = false) {}
+    [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
     public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(CancellationToken cancellationToken) {}
-    public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(bool getUniqueId) {}
-    public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(bool getUniqueId, CancellationToken cancellationToken) {}
+    public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
     public void KeepAlive() {}
     public Task KeepAliveAsync() {}
     public void Logout() {}
     void IDisposable.Dispose() {}
     public override string ToString() {}
     public void UpdateStatus() {}
     public Task UpdateStatusAsync() {}
   }
 
   [Serializable]
   public class PopClientProfile :
     ICloneable,
     IPopSessionProfile,
     ISerializable
   {
     protected PopClientProfile(SerializationInfo info, StreamingContext context) {}
     public PopClientProfile() {}
     public PopClientProfile(Uri authority) {}
-    public PopClientProfile(string host) {}
-    public PopClientProfile(string host, bool securePort, string userName) {}
-    public PopClientProfile(string host, int port) {}
-    public PopClientProfile(string host, int port, bool securePort) {}
-    public PopClientProfile(string host, int port, bool securePort, string userName) {}
-    public PopClientProfile(string host, int port, bool securePort, string userName, string authType) {}
-    public PopClientProfile(string host, int port, bool securePort, string userName, string authType, int timeout) {}
-    public PopClientProfile(string host, int port, string userName) {}
-    public PopClientProfile(string host, int port, string userName, string authType) {}
-    public PopClientProfile(string host, string userName) {}
+    public PopClientProfile(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, bool allowStandardLogin = true, bool allowApopLogin = true) {}
 
     public bool AllowApopLogin { get; set; }
     public bool AllowInsecureLogin { get; set; }
     public bool AllowStandardLogin { 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 IPopSessionProfile.Credentials { get; }
+    IReadOnlyList<string> IPopSessionProfile.UsingSaslMechanisms { get; }
     public int Timeout { get; set; }
     public bool UseTlsIfAvailable { get; set; }
     public string UserName { get; set; }
-    public string[] UsingSaslMechanisms { get; set; }
+    public IList<string> UsingSaslMechanisms { get; }
 
     public PopClientProfile Clone() {}
     public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
+    public void SetUsingSaslMechanisms(IEnumerable<string> mechanisms) {}
     object ICloneable.Clone() {}
   }
 
   public sealed class PopMessage {
     public PopClient Client { get; }
     public bool IsMarkedAsDeleted { get; }
     public long Length { get; }
     public long MessageNumber { get; }
     public string UniqueId { get; }
 
     public string GetUniqueId() {}
     public Task<string> GetUniqueIdAsync() {}
     public void MarkAsDeleted() {}
     public Task MarkAsDeletedAsync() {}
     public Stream OpenRead() {}
     public Stream OpenRead(int maxLines) {}
     public Task<Stream> OpenReadAsync() {}
     public Task<Stream> OpenReadAsync(CancellationToken cancellationToken) {}
     public Task<Stream> OpenReadAsync(CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<Stream> OpenReadAsync(IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<Stream> OpenReadAsync(int maxLines) {}
     public Task<Stream> OpenReadAsync(int maxLines, CancellationToken cancellationToken) {}
     public Task<Stream> OpenReadAsync(int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<Stream> OpenReadAsync(int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public StreamReader OpenText() {}
     public StreamReader OpenText(Encoding encoding) {}
     public StreamReader OpenText(Encoding encoding, int maxLines) {}
     public StreamReader OpenText(int maxLines) {}
     public Task<StreamReader> OpenTextAsync() {}
     public Task<StreamReader> OpenTextAsync(Encoding charset) {}
     public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines) {}
     public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
     public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<StreamReader> OpenTextAsync(int maxLines) {}
     public byte[] ReadAllBytes() {}
     public byte[] ReadAllBytes(int maxLines) {}
     public Task<byte[]> ReadAllBytesAsync() {}
     public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken) {}
     public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<byte[]> ReadAllBytesAsync(IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<byte[]> ReadAllBytesAsync(int maxLines) {}
     public Task<byte[]> ReadAllBytesAsync(int maxLines, CancellationToken cancellationToken) {}
     public Task<byte[]> ReadAllBytesAsync(int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<byte[]> ReadAllBytesAsync(int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public string[] ReadAllLines() {}
     public string[] ReadAllLines(Encoding encoding) {}
     public string[] ReadAllLines(Encoding encoding, int maxLines) {}
     public string[] ReadAllLines(int maxLines) {}
     public Task<string[]> ReadAllLinesAsync() {}
     public Task<string[]> ReadAllLinesAsync(Encoding charset) {}
     public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines) {}
     public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
     public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<string[]> ReadAllLinesAsync(int maxLines) {}
     public string ReadAllText() {}
     public string ReadAllText(Encoding encoding) {}
     public string ReadAllText(Encoding encoding, int maxLines) {}
     public string ReadAllText(int maxLines) {}
     public Task<string> ReadAllTextAsync() {}
     public Task<string> ReadAllTextAsync(Encoding charset) {}
     public Task<string> ReadAllTextAsync(Encoding charset, int maxLines) {}
     public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
     public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<string> ReadAllTextAsync(int maxLines) {}
     public TResult ReadAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
     public TResult ReadAs<T, TResult>(int maxLines, Func<Stream, T, TResult> read, T arg) {}
     public TResult ReadAs<T1, T2, T3, T4, TResult>(Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
     public TResult ReadAs<T1, T2, T3, T4, TResult>(int maxLines, Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
     public TResult ReadAs<T1, T2, T3, TResult>(Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
     public TResult ReadAs<T1, T2, T3, TResult>(int maxLines, Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
     public TResult ReadAs<T1, T2, TResult>(Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
     public TResult ReadAs<T1, T2, TResult>(int maxLines, Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
     public TResult ReadAs<TResult>(Converter<Stream, TResult> converter) {}
     public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter) {}
     public TResult ReadAs<TResult>(Encoding encoding, Converter<StreamReader, TResult> converter) {}
     public TResult ReadAs<TResult>(Encoding encoding, int maxLines, Converter<StreamReader, TResult> converter) {}
     public TResult ReadAs<TResult>(int maxLines, Converter<Stream, TResult> converter) {}
     public TResult ReadAs<TResult>(int maxLines, Converter<StreamReader, TResult> converter) {}
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter) {}
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter) {}
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, Converter<StreamReader, TResult> converter) {}
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter) {}
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter) {}
     public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
     public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<StreamReader, TResult> converter) {}
     public IEnumerable<string> ReadLines() {}
     public IEnumerable<string> ReadLines(Encoding encoding) {}
     public IEnumerable<string> ReadLines(Encoding encoding, int maxLines) {}
     public IEnumerable<string> ReadLines(int maxLines) {}
     public void Save(string path) {}
     public void Save(string path, int maxLines) {}
     public Task SaveAsync(string path) {}
     public Task SaveAsync(string path, CancellationToken cancellationToken) {}
     public Task SaveAsync(string path, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task SaveAsync(string path, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task SaveAsync(string path, int maxLines) {}
     public Task SaveAsync(string path, int maxLines, CancellationToken cancellationToken) {}
     public Task SaveAsync(string path, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task SaveAsync(string path, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public override string ToString() {}
     public bool TryGetUniqueId(out string uniqueId) {}
     public void WriteTo(BinaryWriter writer) {}
     public void WriteTo(BinaryWriter writer, int maxLines) {}
     public void WriteTo(Stream stream) {}
     public void WriteTo(Stream stream, int maxLines) {}
     public Task WriteToAsync(BinaryWriter writer) {}
     public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken) {}
     public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task WriteToAsync(BinaryWriter writer, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task WriteToAsync(BinaryWriter writer, int maxLines) {}
     public Task WriteToAsync(BinaryWriter writer, int maxLines, CancellationToken cancellationToken) {}
     public Task WriteToAsync(BinaryWriter writer, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task WriteToAsync(BinaryWriter writer, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task WriteToAsync(Stream stream) {}
     public Task WriteToAsync(Stream stream, CancellationToken cancellationToken) {}
     public Task WriteToAsync(Stream stream, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task WriteToAsync(Stream stream, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task WriteToAsync(Stream stream, int maxLines) {}
     public Task WriteToAsync(Stream stream, int maxLines, CancellationToken cancellationToken) {}
     public Task WriteToAsync(Stream stream, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
     public Task WriteToAsync(Stream stream, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
   }
 
   [Serializable]
   public class PopMessageDeletedException : PopProtocolViolationException {
     protected PopMessageDeletedException(SerializationInfo info, StreamingContext context) {}
     public PopMessageDeletedException() {}
     public PopMessageDeletedException(long messageNumber) {}
     public PopMessageDeletedException(string message, long messageNumber) {}
 
     public long MessageNumber { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public class PopMessageNotFoundException : PopException {
     protected PopMessageNotFoundException(SerializationInfo info, StreamingContext context) {}
     public PopMessageNotFoundException() {}
     public PopMessageNotFoundException(long messageNumber) {}
     public PopMessageNotFoundException(string uniqueId) {}
 
     public long MessageNumber { get; }
     public string UniqueId { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   public static class PopSslConnection {
     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; }
   }
 
   public struct PopMessageRetrieveProgressInfo {
     public PopMessageRetrieveProgressInfo(long retrievedOctetCount, long retrievedLineCount, long totalOctetCount, CancellationToken cancellationToken) {}
 
     public CancellationToken CancellationToken { get; }
     public int ProgressPercentage { get; }
     public long RetrievedLineCount { get; }
     public long RetrievedOctetCount { get; }
     public long TotalOctetCount { get; }
 
     public override string ToString() {}
   }
 }
 
 namespace Smdn.Net.Pop3.Protocol {
-  public interface IPopExtension {
-    PopCapability RequiredCapability { get; }
-  }
-
   public static class ApopDigest {
     public static string Calculate(ByteString timestamp, ByteString sharedSecret) {}
     public static string Calculate(string timestamp, string sharedSecret) {}
   }
 
   [Serializable]
   public class PopAuthenticationException : PopErrorResponseException {
     protected PopAuthenticationException(SerializationInfo info, StreamingContext context) {}
     public PopAuthenticationException() {}
     public PopAuthenticationException(PopCommandResult result) {}
   }
 
   public sealed class PopAuthenticationMechanism :
     PopStringEnum,
-    IPopExtension
+    IEquatable<PopAuthenticationMechanism>
   {
-    public static readonly PopStringEnumSet<PopAuthenticationMechanism> AllMechanisms; // = "+APOP, KERBEROS_V4, CRAM-MD5, OTP, SKEY, PLAIN, SECURID, DIGEST-MD5, 9798-U-RSA-SHA1-ENC, 9798-M-RSA-SHA1-ENC, 9798-U-DSA-SHA1, 9798-M-DSA-SHA1, 9798-U-ECDSA-SHA1, 9798-M-ECDSA-SHA1, EXTERNAL, ANONYMOUS, GSSAPI, KERBEROS_V5, NTLM, LOGIN, *"
     public static readonly PopAuthenticationMechanism Anonymous; // = "ANONYMOUS"
     public static readonly PopAuthenticationMechanism Apop; // = "+APOP"
     public static readonly PopAuthenticationMechanism CRAMMD5; // = "CRAM-MD5"
     public static readonly PopAuthenticationMechanism DigestMD5; // = "DIGEST-MD5"
     public static readonly PopAuthenticationMechanism External; // = "EXTERNAL"
     public static readonly PopAuthenticationMechanism Gssapi; // = "GSSAPI"
     public static readonly PopAuthenticationMechanism IsoIec9798_M_DSA_SHA1; // = "9798-M-DSA-SHA1"
     public static readonly PopAuthenticationMechanism IsoIec9798_M_ECDSA_SHA1; // = "9798-M-ECDSA-SHA1"
     public static readonly PopAuthenticationMechanism IsoIec9798_M_RSA_SHA1_ENC; // = "9798-M-RSA-SHA1-ENC"
     public static readonly PopAuthenticationMechanism IsoIec9798_U_DSA_SHA1; // = "9798-U-DSA-SHA1"
     public static readonly PopAuthenticationMechanism IsoIec9798_U_ECDSA_SHA1; // = "9798-U-ECDSA-SHA1"
     public static readonly PopAuthenticationMechanism IsoIec9798_U_RSA_SHA1_ENC; // = "9798-U-RSA-SHA1-ENC"
     public static readonly PopAuthenticationMechanism KerberosV4; // = "KERBEROS_V4"
     public static readonly PopAuthenticationMechanism KerberosV5; // = "KERBEROS_V5"
     public static readonly PopAuthenticationMechanism Login; // = "LOGIN"
     public static readonly PopAuthenticationMechanism NTLM; // = "NTLM"
     public static readonly PopAuthenticationMechanism OTP; // = "OTP"
     public static readonly PopAuthenticationMechanism Plain; // = "PLAIN"
     public static readonly PopAuthenticationMechanism SKey; // = "SKEY"
     public static readonly PopAuthenticationMechanism SecureID; // = "SECURID"
     public static readonly PopAuthenticationMechanism SelectAppropriate; // = "*"
 
-    public PopAuthenticationMechanism(string mechanismName) {}
-    public PopAuthenticationMechanism(string mechanismName, PopCapability requiredCapability) {}
+    public PopAuthenticationMechanism(string mechanismName, PopCapability requiredCapability = null) {}
 
+    public static IReadOnlyStringSet<PopAuthenticationMechanism> AllMechanisms { get; }
     public PopCapability RequiredCapability { get; }
 
-    public static PopAuthenticationMechanism GetKnownOrCreate(string mechanismName) {}
+    public bool Equals(PopAuthenticationMechanism other) {}
+    public override bool Equals(object obj) {}
+    public override int GetHashCode() {}
+    public static bool operator == (PopAuthenticationMechanism x, PopAuthenticationMechanism y) {}
+    public static bool operator != (PopAuthenticationMechanism x, PopAuthenticationMechanism y) {}
   }
 
   [Serializable]
-  public sealed class PopCapability : PopStringEnum {
-    public static readonly PopCapabilitySet AllCapabilities; // = "TOP, USER, SASL, RESP-CODES, LOGIN-DELAY, PIPELINING, EXPIRE, UIDL, IMPLEMENTATION, STLS, AUTH-RESP-CODE, UTF8, LANG, SASL KERBEROS_V4, SASL CRAM-MD5, SASL OTP, SASL SKEY, SASL PLAIN, SASL SECURID, SASL DIGEST-MD5, SASL 9798-U-RSA-SHA1-ENC, SASL 9798-M-RSA-SHA1-ENC, SASL 9798-U-DSA-SHA1, SASL 9798-M-DSA-SHA1, SASL 9798-U-ECDSA-SHA1, SASL 9798-M-ECDSA-SHA1, SASL EXTERNAL, SASL ANONYMOUS, SASL GSSAPI, SASL KERBEROS_V5, SASL NTLM, SASL LOGIN"
+  public sealed class PopCapability :
+    PopStringEnum,
+    IEquatable<PopCapability>
+  {
     public static readonly PopCapability AuthRespCode; // = "AUTH-RESP-CODE"
     public static readonly PopCapability Expire; // = "EXPIRE"
     public static readonly PopCapability Implementation; // = "IMPLEMENTATION"
     public static readonly PopCapability Lang; // = "LANG"
     public static readonly PopCapability LoginDelay; // = "LOGIN-DELAY"
     public static readonly PopCapability Pipelining; // = "PIPELINING"
     public static readonly PopCapability RespCodes; // = "RESP-CODES"
     public static readonly PopCapability Sasl; // = "SASL"
     public static readonly PopCapability Stls; // = "STLS"
     public static readonly PopCapability Top; // = "TOP"
     public static readonly PopCapability Uidl; // = "UIDL"
     public static readonly PopCapability User; // = "USER"
     public static readonly PopCapability Utf8; // = "UTF8"
 
     public PopCapability(string tag, params string[] arguments) {}
 
-    public string[] Arguments { get; }
+    public static IReadOnlyStringSet<PopCapability> AllCapabilities { get; }
+    public IReadOnlyList<string> Arguments { get; }
     public string Tag { get; }
     public override string Value { get; }
 
+    public bool ContainsAllArguments(IEnumerable<string> arguments) {}
     public bool ContainsAllArguments(params string[] arguments) {}
-    public override string ToString() {}
+    public bool Equals(PopCapability other) {}
+    public override bool Equals(object obj) {}
+    public override int GetHashCode() {}
+    public static bool operator == (PopCapability x, PopCapability y) {}
+    public static bool operator != (PopCapability x, PopCapability y) {}
   }
 
-  public class PopCapabilitySet : PopStringEnumSet<PopCapability> {
-    public static readonly PopCapabilitySet ReadOnlyEmpty; // = ""
-
-    public PopCapabilitySet() {}
-    public PopCapabilitySet(IEnumerable<PopCapability> caps) {}
-    public PopCapabilitySet(bool readOnly, IEnumerable<PopCapability> caps) {}
-
-    public PopCapability FindByTag(PopCapability capability) {}
-    public PopCapability FindByTag(string tag) {}
-    public bool IsCapable(IPopExtension extension) {}
-    public bool IsCapable(PopCapability requiredCapability) {}
+  public static class PopCapabilitySetExtensions {
+    public static PopCapability FindByTag(this IReadOnlyStringSet<PopCapability> capabilities, PopCapability capability) {}
+    public static PopCapability FindByTag(this IReadOnlyStringSet<PopCapability> capabilities, string tag) {}
+    public static bool IsCapable(this IReadOnlyStringSet<PopCapability> capabilities, PopCapability requiredCapability) {}
+    public static bool IsCapable(this IReadOnlyStringSet<PopCapability> capabilities, PopStringEnum feature) {}
   }
 
   [Serializable]
   public class PopConnectionException : PopException {
     protected PopConnectionException(SerializationInfo info, StreamingContext context) {}
     public PopConnectionException() {}
     public PopConnectionException(string message) {}
     public PopConnectionException(string message, Exception innerException) {}
   }
 
   public static class PopDefaultPorts {
     public const int Pop = 110;
     public const int Pops = 995;
   }
 
   [Serializable]
   public class PopErrorResponseException : PopInvalidOperationException {
     protected PopErrorResponseException(SerializationInfo info, StreamingContext context) {}
     public PopErrorResponseException() {}
     public PopErrorResponseException(PopCommandResult result) {}
-    public PopErrorResponseException(string message, Exception innerException) {}
     public PopErrorResponseException(string message, PopCommandResult result) {}
 
     public PopCommandResult Result { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public class PopIncapableException : PopInvalidOperationException {
     protected PopIncapableException(SerializationInfo info, StreamingContext context) {}
     public PopIncapableException() {}
     public PopIncapableException(PopCapability requiredCapability) {}
     public PopIncapableException(string message) {}
     public PopIncapableException(string message, Exception innerException) {}
     public PopIncapableException(string message, PopCapability requiredCapability) {}
 
     public PopCapability RequiredCapability { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public abstract class PopInvalidOperationException : PopException {
     protected PopInvalidOperationException() {}
     protected PopInvalidOperationException(SerializationInfo info, StreamingContext context) {}
     protected PopInvalidOperationException(string message) {}
     protected PopInvalidOperationException(string message, Exception innerException) {}
   }
 
   [Serializable]
   public class PopNoAppropriateAuthMechanismException : PopException {
     protected PopNoAppropriateAuthMechanismException(SerializationInfo info, StreamingContext context) {}
     public PopNoAppropriateAuthMechanismException() {}
     public PopNoAppropriateAuthMechanismException(string message) {}
     public PopNoAppropriateAuthMechanismException(string message, Exception innerException) {}
   }
 
-  public static class PopOctets {
-    public const byte CloseBracket = 93;
-    public const byte OpenBracket = 91;
-    public const byte Period = 46;
-  }
-
   [Serializable]
   public class PopProtocolViolationException : PopInvalidOperationException {
     protected PopProtocolViolationException(SerializationInfo info, StreamingContext context) {}
     public PopProtocolViolationException() {}
     public PopProtocolViolationException(string message) {}
     public PopProtocolViolationException(string message, Exception innerException) {}
   }
 
   [Serializable]
-  public sealed class PopResponseCode : PopStringEnum {
-    public static readonly PopStringEnumSet<PopResponseCode> AllCodes; // = "LOGIN-DELAY, IN-USE, SYS/TEMP, SYS/PERM, AUTH"
+  public sealed class PopResponseCode :
+    PopStringEnum,
+    IEquatable<PopResponseCode>
+  {
     public static readonly PopResponseCode Auth; // = "AUTH"
     public static readonly PopResponseCode InUse; // = "IN-USE"
     public static readonly PopResponseCode LoginDelay; // = "LOGIN-DELAY"
     public static readonly PopResponseCode SysPerm; // = "SYS/PERM"
     public static readonly PopResponseCode SysTemp; // = "SYS/TEMP"
 
-    public static PopResponseCode GetKnownOrCreate(string code) {}
+    public static IReadOnlyStringSet<PopResponseCode> AllCodes { get; }
+
+    public bool Equals(PopResponseCode other) {}
+    public override bool Equals(object obj) {}
+    public override int GetHashCode() {}
+    public static bool operator == (PopResponseCode x, PopResponseCode y) {}
+    public static bool operator != (PopResponseCode x, PopResponseCode y) {}
   }
 
   [Serializable]
   public class PopUpgradeConnectionException : PopConnectionException {
     protected PopUpgradeConnectionException(SerializationInfo info, StreamingContext context) {}
     public PopUpgradeConnectionException() {}
     public PopUpgradeConnectionException(string message) {}
     public PopUpgradeConnectionException(string message, Exception innerException) {}
   }
 }
 
 namespace Smdn.Net.Pop3.Protocol.DataStructures {
   public struct PopDropListing {
     public static readonly PopDropListing Empty; // = "{MessageCount=0, SizeInOctets=0}"
 
     public PopDropListing(long messageCount, long sizeInOctets) {}
 
     public long MessageCount { get; }
     public long SizeInOctets { get; }
 
     public override string ToString() {}
   }
 
   public struct PopScanListing : IEquatable<long> {
     public static readonly PopScanListing Invalid; // = "{MessageNumber=0, SizeInOctets=0}"
 
     public PopScanListing(long messageNumber, long sizeInOctets) {}
 
     public long MessageNumber { get; }
     public long SizeInOctets { get; }
 
     public bool Equals(long other) {}
     public override string ToString() {}
   }
 
   public struct PopUniqueIdListing :
     IEquatable<long>,
     IEquatable<string>
   {
     public static readonly PopUniqueIdListing Invalid; // = "{MessageNumber=0, UniqueId=}"
 
     public PopUniqueIdListing(long messageNumber, string uniqueId) {}
 
     public long MessageNumber { get; }
     public string UniqueId { get; }
 
     public bool Equals(long other) {}
     public bool Equals(string other) {}
     public override string ToString() {}
   }
 }
 
 namespace Smdn.Net.Pop3.Protocol.Session {
   public interface IPopSessionProfile {
     bool AllowApopLogin { get; }
     bool AllowInsecureLogin { get; }
     bool AllowStandardLogin { get; }
     Uri Authority { get; }
     ICredentialsByHost Credentials { get; }
     int ReceiveTimeout { get; }
     int SendTimeout { get; }
     int Timeout { get; }
     bool UseTlsIfAvailable { get; }
-    string[] UsingSaslMechanisms { get; }
+    IReadOnlyList<string> UsingSaslMechanisms { get; }
   }
 
   public enum PopSessionState : int {
     Authorization = 1,
     NotConnected = 0,
     Transaction = 2,
     Update = 3,
   }
 
-  public sealed class PopSession : IDisposable {
-    public PopSession(string host, int port = 110, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, UpgradeConnectionStreamCallback createAuthenticatedStreamCallback = null) {}
+  public sealed class PopSession :
+    IConnectionInfo,
+    IDisposable
+  {
+    public PopSession(string host, int port = 110, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, UpgradeConnectionStreamCallback createAuthenticatedStream = null) {}
 
     public bool ApopAvailable { get; }
     public Uri Authority { get; }
-    public IConnectionInfo ConnectionInfo { get; }
     public bool HandlesIncapableAsException { get; set; }
     public bool IsDisposed { get; }
     public bool IsSecureConnection { get; }
     public bool IsTransactionProceeding { get; }
     public int ReceiveTimeout { get; set; }
     public int SendTimeout { get; set; }
-    public PopCapabilitySet ServerCapabilities { get; }
+    public IReadOnlyStringSet<PopCapability> ServerCapabilities { get; }
+    string IConnectionInfo.Host { get; }
+    int IConnectionInfo.Port { get; }
     public PopSessionState State { get; }
     public string Timestamp { get; }
     public int TransactionTimeout { get; set; }
 
-    public PopCommandResult Apop(ICredentialsByHost credentials) {}
-    public PopCommandResult Apop(ICredentialsByHost credentials, string username) {}
-    public PopCommandResult Auth(ICredentialsByHost credentials, PopAuthenticationMechanism authenticationMechanism) {}
-    public PopCommandResult Auth(ICredentialsByHost credentials, string username, PopAuthenticationMechanism authenticationMechanism, CancellationToken cancellationToken = default) {}
+    public PopCommandResult Apop(ICredentialsByHost credentials, string username = null) {}
+    public PopCommandResult Auth(PopAuthenticationMechanism authenticationMechanism, ICredentialsByHost credentials, string username = null, CancellationToken cancellationToken = default) {}
     public PopCommandResult Auth(SaslClientMechanism specificAuthenticationMechanism, CancellationToken cancellationToken = default) {}
     public PopCommandResult Capa() {}
-    public PopCommandResult Capa(out PopCapabilitySet capabilities) {}
+    public PopCommandResult Capa(out IReadOnlyStringSet<PopCapability> capabilities) {}
     public PopCommandResult Dele(long messageNumber) {}
     public void Disconnect(bool logout = true) {}
-    public PopCommandResult GenericCommand(string command, bool isResponseMultiline, out PopResponse[] responses, params string[] arguments) {}
+    public PopCommandResult GenericCommand(string command, bool isResponseMultiline, out IReadOnlyList<PopResponse> responses, params string[] arguments) {}
     public PopCommandResult GenericCommand(string command, bool isResponseMultiline, params string[] arguments) {}
-    public PopCommandResult GenericCommand(string command, out PopResponse[] responses, params string[] arguments) {}
+    public PopCommandResult GenericCommand(string command, out IReadOnlyList<PopResponse> responses, params string[] arguments) {}
     public PopCommandResult GenericCommand(string command, params string[] arguments) {}
-    public PopCommandResult List(int expectedResultCount, out List<PopScanListing> scanListings) {}
     public PopCommandResult List(long messageNumber, out PopScanListing scanListing) {}
-    public PopCommandResult List(out List<PopScanListing> scanListings) {}
-    public PopCommandResult Login(ICredentialsByHost credentials) {}
-    public PopCommandResult Login(ICredentialsByHost credentials, string username) {}
+    public PopCommandResult ListAll(out List<PopScanListing> scanListings, int expectedResultCount = 0) {}
+    public PopCommandResult Login(ICredentialsByHost credentials, string username = null) {}
     public PopCommandResult Login(string username, string password) {}
     public PopCommandResult NoOp() {}
     public PopCommandResult Pass(ICredentialsByHost credentials) {}
     public PopCommandResult Pass(string password) {}
     public PopCommandResult Quit() {}
     public PopCommandResult Retr(long messageNumber, ref Stream messageStream) {}
     public PopCommandResult Rset() {}
     public PopCommandResult Stat(out PopDropListing dropListing) {}
-    public PopCommandResult Stls(UpgradeConnectionStreamCallback createAuthenticatedStreamCallback, bool reissueCapability = false) {}
+    public PopCommandResult Stls(UpgradeConnectionStreamCallback createAuthenticatedStream, bool reissueCapability = false) {}
     void IDisposable.Dispose() {}
     public override string ToString() {}
     public PopCommandResult Top(long messageNumber, int lines, ref Stream messageStream) {}
-    public PopCommandResult Uidl(int expectedResultCount, out List<PopUniqueIdListing> uniqueIdListings) {}
     public PopCommandResult Uidl(long messageNumber, out PopUniqueIdListing uniqueIdListing) {}
-    public PopCommandResult Uidl(out List<PopUniqueIdListing> uniqueIdListings) {}
+    public PopCommandResult UidlAll(out List<PopUniqueIdListing> uniqueIdListings, int expectedResultCount = 0) {}
     public PopCommandResult User(ICredentialsByHost credentials) {}
     public PopCommandResult User(string username) {}
   }
 
   public static class PopSessionCreator {
-    public static PopCommandResult CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken, out PopSession session) {}
-    public static PopCommandResult CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, out PopSession session) {}
-    public static PopSession CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken = default) {}
+    public static PopCommandResult CreateSession(out PopSession session, IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
+    public static PopSession CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
   }
 }
 
 namespace Smdn.Net.Pop3.Protocol.Strings {
   [Serializable]
-  public abstract class PopStringEnum :
-    IEquatable<PopStringEnum>,
-    IStringEnum
-  {
-    internal protected PopStringEnum(string @value) {}
+  public abstract class PopStringEnum : IStringEnum {
+    protected PopStringEnum(string @value) {}
 
     public virtual string Value { get; }
 
-    protected static PopStringEnumSet<TStringEnum> CreateDefinedConstantsSet<TStringEnum>() where TStringEnum : PopStringEnum {}
     public bool Equals(IStringEnum other) {}
-    public bool Equals(string other) {}
     public override bool Equals(object obj) {}
-    public virtual bool Equals(PopStringEnum other) {}
-    protected static IEnumerable<TStringEnum> GetDefinedConstants<TStringEnum>() where TStringEnum : PopStringEnum {}
+    public virtual bool Equals(string other) {}
     public override int GetHashCode() {}
     public override string ToString() {}
-    public static bool operator == (PopStringEnum x, PopStringEnum y) {}
-    public static explicit operator string(PopStringEnum str) {}
-    public static bool operator != (PopStringEnum x, PopStringEnum y) {}
-  }
-
-  public class PopStringEnumSet<TStringEnum> : StringEnumSet<TStringEnum> where TStringEnum : PopStringEnum {
-    public PopStringEnumSet() {}
-    public PopStringEnumSet(IEnumerable<TStringEnum> values) {}
   }
 }
 
 namespace Smdn.Net.Pop3.Protocol.Transmission {
   public interface IPopDataResponse {
     ByteString Data { get; }
   }
 
-  public enum PopCommandResultCode : int {
-    ConnectionError = 450,
-    Default = 999,
-    Error = 400,
-    InternalError = 401,
-    Ok = 200,
-    RequestDone = 250,
-    RequestError = 402,
-    ResponseError = 500,
-    SocketTimeout = 408,
-    UpgradeError = 426,
-  }
-
   public enum PopStatusIndicator : int {
-    Negative = 1,
-    Positive = 0,
-    Undefined = 2,
+    Negative = -1,
+    Positive = 1,
+    Undefined = 0,
   }
 
   public sealed class PopCommand {
-    public PopCommand(string command) {}
-    public PopCommand(string command, params string[] parameters) {}
-
     public string Command { get; }
-    public string[] Parameters { get; }
+    public IReadOnlyList<string> Parameters { get; }
 
+    public static PopCommand Create(string command, params string[] parameters) {}
+    public static PopCommand CreateCancelResponse() {}
+    public static PopCommand CreateContinuation(string parameter) {}
     public override string ToString() {}
   }
 
   [Serializable]
   public class PopCommandResult : ISerializable {
     internal protected PopCommandResult(SerializationInfo info, StreamingContext context) {}
-    public PopCommandResult() {}
 
-    public PopCommandResultCode Code { get; }
     public string Description { get; }
-    public bool Failed { get; }
-    public virtual IEnumerable<PopResponse> ReceivedResponses { get; internal protected set; }
-    public string ResponseText { get; }
-    public string ResultText { get; }
+    public virtual bool IsConcludedByClientSide { get; }
+    public virtual bool IsSuccess { get; }
+    public IReadOnlyList<PopResponse> ReceivedResponses { get; }
     public PopStatusResponse StatusResponse { get; }
-    public bool Succeeded { get; }
 
     public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
     public PopStatusResponse GetResponseCode(PopResponseCode code) {}
+    public bool IsResponseStatus(PopStatusIndicator status) {}
     public override string ToString() {}
-    public static explicit operator bool(PopCommandResult r) {}
   }
 
   public sealed class PopCommandSender {
     public PopCommandSender(LineOrientedBufferedStream baseStream) {}
 
     public void Send(PopCommand command) {}
   }
 
   public sealed class PopConnection : ConnectionBase {
-    public PopConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStreamCallback) {}
+    public PopConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStream) {}
 
-    public DateTime LastSentTime { get; }
     public static 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) {}
     public void SendCommand(PopCommand command) {}
     public bool TryReceiveLine(Stream stream, out int receivedLineLength) {}
     public PopResponse TryReceiveResponse() {}
   }
 
   [Serializable]
   public sealed class PopContinuationRequest : PopResponse {
     public ByteString Base64Text { get; }
 
     public override string ToString() {}
   }
 
   [Serializable]
   public sealed class PopFollowingResponse :
     PopResponse,
     IPopDataResponse
   {
     ByteString IPopDataResponse.Data { get; }
     public ByteString Text { get; }
 
     public override string ToString() {}
   }
 
   [Serializable]
-  public class PopFormatException : FormatException {
+  public abstract class PopFormatException : FormatException {
+    protected PopFormatException() {}
     protected PopFormatException(SerializationInfo info, StreamingContext context) {}
-    public PopFormatException() {}
-    public PopFormatException(string message) {}
-    public PopFormatException(string message, Exception innerException) {}
+    protected PopFormatException(string message) {}
+    protected PopFormatException(string message, Exception innerException) {}
   }
 
   [Serializable]
   public class PopMalformedResponseException : PopFormatException {
     protected PopMalformedResponseException(SerializationInfo info, StreamingContext context) {}
     public PopMalformedResponseException() {}
     public PopMalformedResponseException(string message) {}
     public PopMalformedResponseException(string message, Exception innerException) {}
     public PopMalformedResponseException(string message, string causedResponse) {}
 
     public string CausedResponse { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public class PopMalformedTextException : PopFormatException {
     protected PopMalformedTextException(SerializationInfo info, StreamingContext context) {}
     public PopMalformedTextException() {}
     public PopMalformedTextException(ByteString causedText) {}
     public PopMalformedTextException(string message) {}
     public PopMalformedTextException(string message, ByteString causedText) {}
     public PopMalformedTextException(string message, Exception innerException) {}
 
     public ByteString CausedText { get; }
 
     public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
   }
 
   [Serializable]
   public abstract class PopResponse {
-    internal protected PopResponse() {}
   }
 
   public static class PopResponseParser {
     public static PopCapability FromCapa(PopFollowingResponse response) {}
     public static string FromGreetingBanner(PopStatusResponse response) {}
     public static PopScanListing FromList(PopFollowingResponse response) {}
     public static PopScanListing FromList(PopStatusResponse response) {}
     public static PopDropListing FromStat(PopStatusResponse response) {}
     public static PopUniqueIdListing FromUidl(PopFollowingResponse response) {}
     public static PopUniqueIdListing FromUidl(PopStatusResponse response) {}
   }
 
   public sealed class PopResponseReceiver {
     public PopResponseReceiver(LineOrientedBufferedStream baseStream) {}
 
     public bool HandleAsMultiline { get; set; }
 
     public bool ReceiveLine(Stream stream, out int length) {}
     public PopResponse ReceiveResponse() {}
   }
 
   [Serializable]
   public sealed class PopResponseText {
     public PopResponseCode Code { get; }
     public ByteString Text { get; }
 
     public string GetTextAsString() {}
     public override string ToString() {}
   }
 
   [Serializable]
   public sealed class PopStatusResponse :
     PopResponse,
     IPopDataResponse
   {
     public PopResponseText ResponseText { get; }
     ByteString IPopDataResponse.Data { get; }
     public PopStatusIndicator Status { get; }
     public string Text { get; }
 
     public override string ToString() {}
   }
 
   [Serializable]
   public sealed class PopTerminationResponse : PopResponse {
+    public override string ToString() {}
   }
 
   public static class PopTextParser {
     public static PopCapability ToCapability(ByteString[] texts) {}
     public static PopDropListing ToDropListing(ByteString messageCount, ByteString sizeInOctets) {}
     public static long ToMessageNumber(ByteString text) {}
     public static long ToNumber(ByteString text) {}
     public static PopScanListing ToScanListing(ByteString messageNumber, ByteString sizeInOctets) {}
     public static string ToString(ByteString text) {}
     public static PopUniqueIdListing ToUniqueIdListing(ByteString messageNumber, ByteString uniqueId) {}
   }
 }
 
 namespace Smdn.Net.Pop3.Urls {
   public class PopStyleUriParser : GenericUriParser {
     public PopStyleUriParser() {}
 
     protected static void CheckUriScheme(Uri uri) {}
     public static PopAuthenticationMechanism GetAuthType(Uri uri) {}
     public static string GetAuthority(Uri uri) {}
     public static string GetStrongAuthority(Uri uri) {}
     public static string GetUser(Uri uri) {}
     protected override void InitializeAndValidate(Uri uri, out UriFormatException parsingError) {}
   }
 
   public static class PopUri {
     public static readonly string UriSchemePop = "pop";
     public static readonly string UriSchemePops = "pops";
 
     public static int GetDefaultPortFromScheme(Uri uri) {}
     public static int GetDefaultPortFromScheme(string scheme) {}
     public static bool IsPop(Uri uri) {}
     public static void RegisterParser() {}
   }
 
   public class PopUriBuilder :
     ICloneable,
     IEquatable<PopUriBuilder>,
     IEquatable<Uri>
   {
     public PopUriBuilder() {}
     public PopUriBuilder(Uri uri) {}
     public PopUriBuilder(bool popsScheme, string host) {}
     public PopUriBuilder(bool popsScheme, string host, int port) {}
     public PopUriBuilder(bool popsScheme, string host, int port, string userName, PopAuthenticationMechanism authType) {}
     public PopUriBuilder(bool popsScheme, string host, string userName, PopAuthenticationMechanism authType) {}
     public PopUriBuilder(string host, int port) {}
     public PopUriBuilder(string host, int port, string userName, PopAuthenticationMechanism authType) {}
     public PopUriBuilder(string host, string userName, PopAuthenticationMechanism authType) {}
     public PopUriBuilder(string uri) {}
 
     public PopAuthenticationMechanism AuthType { get; set; }
     public string Host { get; set; }
     public int Port { get; set; }
     public string Scheme { get; set; }
     public Uri Uri { get; }
     public string UserName { get; set; }
 
     public PopUriBuilder Clone() {}
     public bool Equals(PopUriBuilder other) {}
     public bool Equals(Uri other) {}
     public override bool Equals(object obj) {}
     public override int GetHashCode() {}
     object ICloneable.Clone() {}
     public override string ToString() {}
   }
 }