1.91-netstandard2.0_vs_2.0alpha1-netstandard2.0.apilist.diff
--- Smdn.Net.Imap4.Client-1.91-netstandard2.0.apilist.cs 2019-01-30 03:03:25.018175542 +0900
+++ Smdn.Net.Imap4.Client-2.0alpha1-netstandard2.0.apilist.cs 2019-01-30 03:03:27.926127636 +0900
@@ -1,3428 +1,3093 @@
-// Smdn.Net.Imap4.Client-1.91 (netstandard2.0)
+// Smdn.Net.Imap4.Client-2.0alpha1 (netstandard2.0)
// Name: Smdn.Net.Imap4.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;
using System.Collections.Generic;
-using System.Collections.ObjectModel;
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.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) {}
- public ImapClient(string host) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public ImapClient(string host, bool securePort, string userName) {}
- public ImapClient(string host, int port) {}
- public ImapClient(string host, int port, bool securePort) {}
- public ImapClient(string host, int port, bool securePort, string userName) {}
- public ImapClient(string host, int port, bool securePort, string userName, string authType) {}
- public ImapClient(string host, int port, bool securePort, string userName, string authType, int timeout) {}
+ 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 ImapCapabilitySet DisabledCapabilities { get; }
+ 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 ImapCapabilitySet ServerCapabilities { get; }
+ 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; }
- 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 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) {}
- 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 static ImapMailbox CopyMailbox(ImapMailbox mailbox, ImapClient destinationSession, string destinationMailboxName) {}
- public static ImapMailbox CopyMailbox(ImapMailbox mailbox, ImapClient destinationSession, string destinationMailboxName, bool recursive) {}
- public static ImapMailbox CopyMailbox(ImapMailbox mailbox, ImapClient destinationSession, string destinationMailboxName, bool recursive, bool subscribe) {}
- public static void CopyMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox) {}
- public static void CopyMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox, bool recursive) {}
- public static void CopyMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox, bool recursive, bool subscribe) {}
- public ImapMailbox CreateMailbox(string mailboxName) {}
- public ImapMailbox CreateMailbox(string mailboxName, bool subscribeIfCreated) {}
- public Task<ImapMailbox> CreateMailboxAsync(string mailboxName) {}
- public Task<ImapMailbox> CreateMailboxAsync(string mailboxName, bool subscribeIfCreated) {}
- public void Disconnect() {}
- public void Disconnect(bool logout) {}
+ 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() {}
- public ImapMailbox GetInbox(ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetInboxAsync() {}
- public Task<ImapMailbox> GetInboxAsync(ImapMailboxListOptions options) {}
- public ImapMailbox GetMailbox(ImapSpecialMailbox specialMailbox) {}
- public ImapMailbox GetMailbox(ImapSpecialMailbox specialMailbox, ImapMailboxListOptions options) {}
- public ImapMailbox GetMailbox(string mailboxName) {}
- public ImapMailbox GetMailbox(string mailboxName, ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetMailboxAsync(ImapSpecialMailbox specialMailbox) {}
- public Task<ImapMailbox> GetMailboxAsync(ImapSpecialMailbox specialMailbox, ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetMailboxAsync(string mailboxName) {}
- public Task<ImapMailbox> GetMailboxAsync(string mailboxName, ImapMailboxListOptions options) {}
- public IReadOnlyList<ImapMailbox> GetMailboxes() {}
- public IReadOnlyList<ImapMailbox> GetMailboxes(ImapMailboxListOptions options) {}
- public Task<IReadOnlyList<ImapMailbox>> GetMailboxesAsync() {}
- public Task<IReadOnlyList<ImapMailbox>> GetMailboxesAsync(ImapMailboxListOptions options) {}
- public ImapMailbox GetOrCreateMailbox(string mailboxName) {}
+ 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) {}
- public ImapMailbox GetOrCreateMailbox(string mailboxName, bool subscribeIfCreated, ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetOrCreateMailboxAsync(string mailboxName) {}
+ 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) {}
- public Task<ImapMailbox> GetOrCreateMailboxAsync(string mailboxName, bool subscribeIfCreated, 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) {}
- public static ImapMailbox MoveMailbox(ImapMailbox mailbox, ImapClient destinationSession, string destinationMailboxName, bool recursive) {}
- public static ImapMailbox MoveMailbox(ImapMailbox mailbox, ImapClient destinationSession, string destinationMailboxName, bool recursive, bool subscribe) {}
- public static void MoveMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox) {}
- public static void MoveMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox, bool recursive) {}
- public static void MoveMailbox(ImapMailbox mailbox, ImapMailbox destinationMailbox, bool recursive, bool subscribe) {}
- public ImapOpenMailbox OpenInbox() {}
- public ImapOpenMailbox OpenInbox(bool asReadOnly) {}
- public Task<ImapOpenMailbox> OpenInboxAsync() {}
- public Task<ImapOpenMailbox> OpenInboxAsync(bool asReadOnly) {}
- public ImapOpenMailbox OpenMailbox(ImapMailbox mailbox) {}
- public ImapOpenMailbox OpenMailbox(ImapMailbox mailbox, bool asReadOnly) {}
- public ImapOpenMailbox OpenMailbox(ImapSpecialMailbox specialMailbox) {}
+ 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, ImapMailboxListOptions options, bool asReadOnly) {}
- public ImapOpenMailbox OpenMailbox(ImapSpecialMailbox specialMailbox, bool asReadOnly) {}
- public ImapOpenMailbox OpenMailbox(string mailboxName) {}
+ 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, ImapMailboxListOptions options, bool asReadOnly) {}
- public ImapOpenMailbox OpenMailbox(string mailboxName, bool asReadOnly) {}
+ 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) {}
- public Task<ImapOpenMailbox> OpenMailboxAsync(ImapMailbox mailbox, bool asReadOnly) {}
- public Task<ImapOpenMailbox> OpenMailboxAsync(ImapSpecialMailbox specialMailbox) {}
+ 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, ImapMailboxListOptions options, bool asReadOnly) {}
- public Task<ImapOpenMailbox> OpenMailboxAsync(ImapSpecialMailbox specialMailbox, bool asReadOnly) {}
+ public Task<ImapOpenMailbox> OpenMailboxAsync(ImapSpecialMailbox specialMailbox, bool asReadOnly = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
+ [Obsolete("use OpenInboxAsync() instead")]
public Task<ImapOpenMailbox> OpenMailboxAsync(bool asReadOnly) {}
- public Task<ImapOpenMailbox> OpenMailboxAsync(string mailboxName) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<ImapOpenMailbox> OpenMailboxAsync(string mailboxName, ImapMailboxListOptions options) {}
- public Task<ImapOpenMailbox> OpenMailboxAsync(string mailboxName, ImapMailboxListOptions options, bool asReadOnly) {}
- public Task<ImapOpenMailbox> OpenMailboxAsync(string mailboxName, bool asReadOnly) {}
- public ImapOpenMailbox OpenOrCreateMailbox(string mailboxName) {}
+ 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 asReadOnly) {}
- public ImapOpenMailbox OpenOrCreateMailbox(string mailboxName, bool subscribeIfCreated, bool asReadOnly, ImapMailboxListOptions options) {}
- public Task<ImapOpenMailbox> OpenOrCreateMailboxAsync(string mailboxName) {}
+ 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 asReadOnly) {}
- public Task<ImapOpenMailbox> OpenOrCreateMailboxAsync(string mailboxName, bool subscribeIfCreated, bool asReadOnly, 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) {}
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) {}
- public ImapClientProfile(string host, bool securePort, string userName) {}
- public ImapClientProfile(string host, int port) {}
- public ImapClientProfile(string host, int port, bool securePort) {}
- public ImapClientProfile(string host, int port, bool securePort, string userName) {}
- public ImapClientProfile(string host, int port, bool securePort, string userName, string authType) {}
- public ImapClientProfile(string host, int port, bool securePort, string userName, string authType, int timeout) {}
- public ImapClientProfile(string host, int port, string userName) {}
- public ImapClientProfile(string host, int port, string userName, string authType) {}
- public ImapClientProfile(string host, string userName) {}
+ 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 string[] UsingSaslMechanisms { 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 IImapMailboxFlagSet Flags { 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) {}
+ 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) {}
- public void AppendMessage(DateTimeOffset appendDate, IImapMessageFlagSet flags, 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(IImapMessageFlagSet flags, Action<Stream> writeMessage) {}
public void AppendMessage(ImapMessage message) {}
- public void AppendMessage(Stream stream) {}
- public void AppendMessage(Stream stream, DateTimeOffset appendDate) {}
- public void AppendMessage(Stream stream, DateTimeOffset appendDate, IImapMessageFlagSet flags) {}
- public void AppendMessage(Stream stream, IImapMessageFlagSet flags) {}
- public void AppendMessage(long length, Action<Stream> writeMessage) {}
+ 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) {}
- public void AppendMessage(long length, DateTimeOffset appendDate, IImapMessageFlagSet flags, Action<Stream> writeMessage) {}
- public void AppendMessage(long length, IImapMessageFlagSet flags, Action<Stream> writeMessage) {}
- public Task AppendMessageAsync(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) {}
- public Task AppendMessageAsync(DateTimeOffset appendDate, IImapMessageFlagSet flags, 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(IImapMessageFlagSet flags, Action<Stream> writeMessage) {}
public Task AppendMessageAsync(ImapMessage message) {}
- public Task AppendMessageAsync(Stream stream) {}
- public Task AppendMessageAsync(Stream stream, DateTimeOffset appendDate) {}
- public Task AppendMessageAsync(Stream stream, DateTimeOffset appendDate, IImapMessageFlagSet flags) {}
- public Task AppendMessageAsync(Stream stream, IImapMessageFlagSet flags) {}
- public Task AppendMessageAsync(long length, Action<Stream> writeMessage) {}
+ 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) {}
- public Task AppendMessageAsync(long length, DateTimeOffset appendDate, IImapMessageFlagSet flags, Action<Stream> writeMessage) {}
- public Task AppendMessageAsync(long length, IImapMessageFlagSet flags, 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) {}
- public static ImapMailbox Create(ImapClient client, string mailboxName, bool subscribe) {}
- public void Create() {}
- public void Create(bool subscribe) {}
- public Task CreateAsync() {}
- public Task CreateAsync(bool subscribe) {}
- public static Task<ImapMailbox> CreateAsync(ImapClient client, string mailboxName) {}
- public static Task<ImapMailbox> CreateAsync(ImapClient client, string mailboxName, bool subscribe) {}
- public ImapMailbox CreateChild(string name) {}
- public ImapMailbox CreateChild(string name, bool subscribe) {}
- public Task<ImapMailbox> CreateChildAsync(string name) {}
- public Task<ImapMailbox> CreateChildAsync(string name, bool subscribe) {}
- public void Delete() {}
- public void Delete(bool unsubscribe) {}
- public Task DeleteAsync() {}
- public Task DeleteAsync(bool unsubscribe) {}
- public ImapMailbox GetChild(string name) {}
- public ImapMailbox GetChild(string name, ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetChildAsync(string name) {}
- public Task<ImapMailbox> GetChildAsync(string name, ImapMailboxListOptions options) {}
- public IReadOnlyList<ImapMailbox> GetChildren() {}
- public IReadOnlyList<ImapMailbox> GetChildren(ImapMailboxListOptions options) {}
- public Task<IReadOnlyList<ImapMailbox>> GetChildrenAsync() {}
- public Task<IReadOnlyList<ImapMailbox>> GetChildrenAsync(ImapMailboxListOptions options) {}
+ 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) {}
- public ImapMailbox GetOrCreateChild(string name) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public ImapMailbox GetOrCreateChild(string name, ImapMailboxListOptions options) {}
- public ImapMailbox GetOrCreateChild(string name, bool subscribeIfCreated) {}
- public ImapMailbox GetOrCreateChild(string name, bool subscribeIfCreated, ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetOrCreateChildAsync(string name) {}
+ 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) {}
- public Task<ImapMailbox> GetOrCreateChildAsync(string name, bool subscribeIfCreated, ImapMailboxListOptions options) {}
- public ImapMailbox GetOrCreateParent() {}
+ public Task<ImapMailbox> GetOrCreateChildAsync(string name, bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
public ImapMailbox GetOrCreateParent(ImapMailboxListOptions options) {}
- public ImapMailbox GetOrCreateParent(bool subscribeIfCreated) {}
- public ImapMailbox GetOrCreateParent(bool subscribeIfCreated, ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetOrCreateParentAsync() {}
+ public ImapMailbox GetOrCreateParent(bool subscribeIfCreated = false, ImapMailboxListOptions options = ImapMailboxListOptions.Default) {}
public Task<ImapMailbox> GetOrCreateParentAsync(ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetOrCreateParentAsync(bool subscribeIfCreated) {}
- public Task<ImapMailbox> GetOrCreateParentAsync(bool subscribeIfCreated, ImapMailboxListOptions options) {}
- public ImapMailbox GetParent() {}
- public ImapMailbox GetParent(ImapMailboxListOptions options) {}
- public Task<ImapMailbox> GetParentAsync() {}
- public Task<ImapMailbox> GetParentAsync(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) {}
- public void MoveTo(ImapMailbox destinationMailbox, bool subscribe) {}
- public void MoveTo(string newMailboxName) {}
- public void MoveTo(string newMailboxName, bool subscribe) {}
- public Task MoveToAsync(ImapMailbox destinationMailbox) {}
- public Task MoveToAsync(ImapMailbox destinationMailbox, bool subscribe) {}
- public Task MoveToAsync(string newMailboxName) {}
- public Task MoveToAsync(string newMailboxName, bool subscribe) {}
- public ImapOpenMailbox Open() {}
- public virtual ImapOpenMailbox Open(bool asReadOnly) {}
- public Task<ImapOpenMailbox> OpenAsync() {}
- public virtual Task<ImapOpenMailbox> OpenAsync(bool asReadOnly) {}
+ 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) {}
protected void ReRetrieveMailboxFlags() {}
- public void Refresh() {}
- public void Refresh(bool reretrieveMailboxFlags) {}
- public Task RefreshAsync() {}
- public Task RefreshAsync(bool 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() {}
- public void Subscribe(bool recursive) {}
- public Task SubscribeAsync() {}
- public Task SubscribeAsync(bool recursive) {}
- public override string ToString() {}
- public void Unsubscribe() {}
- public void Unsubscribe(bool recursive) {}
- public Task UnsubscribeAsync() {}
- public Task UnsubscribeAsync(bool recursive) {}
+ 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,
- IImapMessageAttribute
+ IImapMessageDynamicAttributes,
+ IImapMessageStaticAttributes,
+ IImapUrl
{
public static readonly long ExpungedMessageSequenceNumber = 0;
public DateTimeOffset DeliveredDate { get; }
public ImapEnvelope Envelope { get; }
public DateTimeOffset? EnvelopeDate { get; }
public string EnvelopeSubject { get; }
- public IImapMessageFlagSet Flags { get; }
+ public IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
public bool HasEncapsulatedMessage { 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; }
- IImapBodyStructure IImapMessageStaticAttribute.BodyStructure { get; }
- DateTimeOffset? IImapMessageStaticAttribute.InternalDate { get; }
- long IImapMessageStaticAttribute.Rfc822Size { 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; }
public Stream Download() {}
public Stream Download(ImapMessageFetchBodyOptions options) {}
public Task<Stream> DownloadAsync() {}
public Task<Stream> DownloadAsync(CancellationToken cancellationToken) {}
public Task<Stream> DownloadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> DownloadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options) {}
public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public List<ImapMessagePart> FindAllMessageParts(MimeType mediaType) {}
public List<ImapMessagePart> FindAllMessageParts(Predicate<ImapMessagePart> match) {}
public ImapMessagePart FindMessagePart(MimeType mediaType) {}
public ImapMessagePart FindMessagePart(Predicate<ImapMessagePart> match) {}
- public KeyValuePair<string, string>[] GetHeader() {}
- public KeyValuePair<string, string>[] GetHeader(IEnumerable<string> headerFields) {}
- public KeyValuePair<string, string>[] GetHeader(bool decode, IEnumerable<string> headerFields) {}
- public KeyValuePair<string, string>[] GetHeader(bool decode, params string[] headerFields) {}
- public KeyValuePair<string, string>[] GetHeader(params string[] headerFields) {}
- public Task<KeyValuePair<string, string>[]> GetHeaderAsync() {}
- public Task<KeyValuePair<string, string>[]> GetHeaderAsync(IEnumerable<string> headerFields) {}
- public Task<KeyValuePair<string, string>[]> GetHeaderAsync(bool decode, IEnumerable<string> headerFields) {}
- public Task<KeyValuePair<string, string>[]> GetHeaderAsync(bool decode, params string[] headerFields) {}
- public Task<KeyValuePair<string, string>[]> GetHeaderAsync(params string[] headerFields) {}
+ public IReadOnlyList<KeyValuePair<string, string>> GetHeader() {}
+ public IReadOnlyList<KeyValuePair<string, string>> GetHeader(IEnumerable<string> headerFields) {}
+ public IReadOnlyList<KeyValuePair<string, string>> GetHeader(bool decode, IEnumerable<string> headerFields) {}
+ public IReadOnlyList<KeyValuePair<string, string>> GetHeader(bool decode, params string[] headerFields) {}
+ public IReadOnlyList<KeyValuePair<string, string>> GetHeader(params string[] headerFields) {}
+ public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync() {}
+ public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(IEnumerable<string> headerFields) {}
+ public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(bool decode, IEnumerable<string> headerFields) {}
+ public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(bool decode, params string[] headerFields) {}
+ 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) {}
public string GetRawHeader() {}
public string GetRawHeader(IEnumerable<string> headerFields) {}
public string GetRawHeader(params string[] headerFields) {}
public Task<string> GetRawHeaderAsync() {}
public Task<string> GetRawHeaderAsync(IEnumerable<string> headerFields) {}
public Task<string> GetRawHeaderAsync(params string[] headerFields) {}
protected override ImapSequenceSet GetSequenceOrUidSet() {}
public Stream OpenRead() {}
public Stream OpenRead(CancellationToken cancellationToken) {}
public Stream OpenRead(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Stream OpenRead(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Stream OpenRead(ImapFetchRange? fetchRange) {}
public Stream OpenRead(ImapFetchRange? fetchRange, ImapMessageFetchBodyOptions options) {}
public Stream OpenRead(ImapMessageFetchBodyOptions options) {}
public Stream OpenRead(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Stream OpenRead(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Stream OpenRead(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> OpenReadAsync() {}
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken) {}
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public StreamReader OpenText() {}
public StreamReader OpenText(Encoding charset) {}
public StreamReader OpenText(Encoding charset, ImapMessageFetchBodyOptions options) {}
public StreamReader OpenText(ImapMessageFetchBodyOptions options) {}
public Task<StreamReader> OpenTextAsync() {}
public Task<StreamReader> OpenTextAsync(Encoding charset) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options) {}
public byte[] ReadAllBytes() {}
public byte[] ReadAllBytes(ImapMessageFetchBodyOptions options) {}
public Task<byte[]> ReadAllBytesAsync() {}
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken) {}
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public string[] ReadAllLines() {}
public string[] ReadAllLines(Encoding charset) {}
public string[] ReadAllLines(Encoding charset, ImapMessageFetchBodyOptions options) {}
public string[] ReadAllLines(ImapMessageFetchBodyOptions options) {}
public Task<string[]> ReadAllLinesAsync() {}
public Task<string[]> ReadAllLinesAsync(Encoding charset) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options) {}
public string ReadAllText() {}
public string ReadAllText(Encoding charset) {}
public string ReadAllText(Encoding charset, ImapMessageFetchBodyOptions options) {}
public string ReadAllText(ImapMessageFetchBodyOptions options) {}
public Task<string> ReadAllTextAsync() {}
public Task<string> ReadAllTextAsync(Encoding charset) {}
public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options) {}
public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string> ReadAllTextAsync(Encoding charset, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options) {}
public TResult ReadAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public TResult ReadAs<T, TResult>(ImapMessageFetchBodyOptions options, 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>(ImapMessageFetchBodyOptions options, 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>(ImapMessageFetchBodyOptions options, 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>(ImapMessageFetchBodyOptions options, 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 charset, Converter<StreamReader, TResult> converter) {}
public TResult ReadAs<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, 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<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> 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, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
public IEnumerable<string> ReadLines() {}
public IEnumerable<string> ReadLines(Encoding charset) {}
public IEnumerable<string> ReadLines(Encoding charset, ImapMessageFetchBodyOptions options) {}
public IEnumerable<string> ReadLines(ImapMessageFetchBodyOptions options) {}
public void Refresh() {}
public Task RefreshAsync() {}
public void Save(string path) {}
public void Save(string path, ImapMessageFetchBodyOptions options) {}
public Task SaveAsync(string path) {}
public Task SaveAsync(string path, CancellationToken cancellationToken) {}
public Task SaveAsync(string path, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task SaveAsync(string path, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task SaveAsync(string path, ImapMessageFetchBodyOptions options) {}
public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
- long IImapMessageStaticAttribute.GetBinarySizeOf(string section) {}
+ long IImapMessageStaticAttributes.GetBinarySizeOf(string section) {}
void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
public override string ToString() {}
- public void ToggleFlags(IImapMessageFlagSet flagsAndKeywords) {}
+ public void ToggleFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
public void ToggleFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public Task ToggleFlagsAsync(IImapMessageFlagSet flagsAndKeywords) {}
+ 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) {}
public void WriteTo(BinaryWriter writer) {}
public void WriteTo(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
public void WriteTo(Stream stream) {}
public void WriteTo(Stream stream, ImapMessageFetchBodyOptions options) {}
public Task WriteToAsync(BinaryWriter writer) {}
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken) {}
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream) {}
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken) {}
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
}
public abstract class ImapMessageBase {
protected ImapMessageBase(ImapOpenMailbox mailbox) {}
public ImapClient Client { get; }
public bool IsAvailable { get; }
public ImapOpenMailbox Mailbox { get; }
public long UidValidity { get; protected set; }
- public void AddFlags(IImapMessageFlagSet flagsAndKeywords) {}
+ public void AddFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
public void AddFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public Task AddFlagsAsync(IImapMessageFlagSet flagsAndKeywords) {}
+ 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(IImapMessageFlagSet flagsAndKeywords) {}
+ public void RemoveFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
public void RemoveFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public Task RemoveFlagsAsync(IImapMessageFlagSet flagsAndKeywords) {}
+ 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(IImapMessageFlagSet flagsAndKeywords) {}
+ public void SetFlags(IEnumerable<ImapMessageFlag> flagsAndKeywords) {}
public void SetFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public Task SetFlagsAsync(IImapMessageFlagSet flagsAndKeywords) {}
+ 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(ImapStoreDataItem storeDataItem) {}
- public Task StoreAsync(ImapStoreDataItem storeDataItem) {}
- protected void StoreCore(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem) {}
+ public void Store(ImapStoreDataItems storeDataItems) {}
+ public Task StoreAsync(ImapStoreDataItems storeDataItems) {}
+ protected void StoreCore(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItems storeDataItems) {}
}
[Serializable]
public class ImapMessageNotFoundException : ImapException {
protected ImapMessageNotFoundException(SerializationInfo info, StreamingContext context) {}
public ImapMessageNotFoundException(ImapSequenceSet sequenceOrUidSet) {}
public ImapMessageNotFoundException(string message, ImapSequenceSet sequenceOrUidSet) {}
public ImapSequenceSet 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 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 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; }
public Stream Download() {}
public Stream Download(ImapMessageFetchBodyOptions options) {}
public Task<Stream> DownloadAsync() {}
public Task<Stream> DownloadAsync(CancellationToken cancellationToken) {}
public Task<Stream> DownloadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> DownloadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options) {}
public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<Stream> DownloadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
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 string GetContentFileName() {}
public string GetContentFileName(EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
- public KeyValuePair<string, string>[] GetHeader() {}
- public KeyValuePair<string, string>[] GetHeader(bool decode) {}
- public Task<KeyValuePair<string, string>[]> GetHeaderAsync() {}
- public Task<KeyValuePair<string, string>[]> GetHeaderAsync(bool decode) {}
+ public IReadOnlyList<KeyValuePair<string, string>> GetHeader() {}
+ public IReadOnlyList<KeyValuePair<string, string>> GetHeader(bool decode) {}
+ public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync() {}
+ public Task<IReadOnlyList<KeyValuePair<string, string>>> GetHeaderAsync(bool decode) {}
public string GetRawHeader() {}
public Task<string> GetRawHeaderAsync() {}
public Stream OpenRead() {}
public Stream OpenRead(ImapFetchRange? fetchRange) {}
public Stream OpenRead(ImapFetchRange? fetchRange, ImapMessageFetchBodyOptions options) {}
public Stream OpenRead(ImapMessageFetchBodyOptions options) {}
public Task<Stream> OpenReadAsync() {}
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken) {}
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public StreamReader OpenText() {}
public StreamReader OpenText(ImapMessageFetchBodyOptions options) {}
public StreamReader OpenText(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
public Task<StreamReader> OpenTextAsync() {}
public Task<StreamReader> OpenTextAsync(CancellationToken cancellationToken) {}
public Task<StreamReader> OpenTextAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<StreamReader> OpenTextAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options) {}
public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress, EncodingSelectionCallback selectFallbackCharset) {}
public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
public Task<StreamReader> OpenTextAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public byte[] ReadAllBytes() {}
public byte[] ReadAllBytes(ImapMessageFetchBodyOptions options) {}
public Task<byte[]> ReadAllBytesAsync() {}
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken) {}
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public string[] ReadAllLines() {}
public string[] ReadAllLines(ImapMessageFetchBodyOptions options) {}
public string[] ReadAllLines(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
public Task<string[]> ReadAllLinesAsync() {}
public Task<string[]> ReadAllLinesAsync(CancellationToken cancellationToken) {}
public Task<string[]> ReadAllLinesAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string[]> ReadAllLinesAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options) {}
public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress, EncodingSelectionCallback selectFallbackCharset) {}
public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
public Task<string[]> ReadAllLinesAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public string ReadAllText() {}
public string ReadAllText(ImapMessageFetchBodyOptions options) {}
public string ReadAllText(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
public Task<string> ReadAllTextAsync() {}
public Task<string> ReadAllTextAsync(CancellationToken cancellationToken) {}
public Task<string> ReadAllTextAsync(CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string> ReadAllTextAsync(IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options) {}
public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress, EncodingSelectionCallback selectFallbackCharset) {}
public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
public Task<string> ReadAllTextAsync(ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public TResult ReadAs<TResult>(Converter<Stream, TResult> converter) {}
public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter) {}
public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
public TResult ReadAs<TResult>(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset, 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<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<Stream, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, EncodingSelectionCallback selectFallbackCharset) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, Converter<StreamReader, TResult> converter, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public IEnumerable<string> ReadLines() {}
public IEnumerable<string> ReadLines(ImapMessageFetchBodyOptions options) {}
public IEnumerable<string> ReadLines(ImapMessageFetchBodyOptions options, EncodingSelectionCallback selectFallbackCharset) {}
public void Save(string path) {}
public void Save(string path, ImapMessageFetchBodyOptions options) {}
public Task SaveAsync(string path) {}
public Task SaveAsync(string path, CancellationToken cancellationToken) {}
public Task SaveAsync(string path, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task SaveAsync(string path, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task SaveAsync(string path, ImapMessageFetchBodyOptions options) {}
public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task SaveAsync(string path, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
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) {}
public void WriteTo(BinaryWriter writer) {}
public void WriteTo(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
public void WriteTo(Stream stream) {}
public void WriteTo(Stream stream, ImapMessageFetchBodyOptions options) {}
public Task WriteToAsync(BinaryWriter writer) {}
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken) {}
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream) {}
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken) {}
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, CancellationToken cancellationToken, IProgress<ImapMessageFetchProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, ImapMessageFetchBodyOptions options, IProgress<ImapMessageFetchProgressInfo> progress) {}
}
public abstract class ImapMessageQuery :
ImapMessageBase,
IEnumerable<ImapMessage>
{
protected ImapMessageQuery(ImapOpenMailbox mailbox, ImapMessageFetchAttributeOptions fetchOptions, bool orderBySequenceNumber) {}
public IEnumerator<ImapMessage> GetEnumerator() {}
IEnumerator IEnumerable.GetEnumerator() {}
public ImapMessage[] ToArray() {}
- public Task<ImapMessage[]> ToArrayAsync() {}
- public Task<ImapMessage[]> ToArrayAsync(CancellationToken cancellationToken) {}
+ public Task<ImapMessage[]> ToArrayAsync(CancellationToken cancellationToken = default) {}
public List<ImapMessage> ToList() {}
- public Task<List<ImapMessage>> ToListAsync() {}
- public Task<List<ImapMessage>> ToListAsync(CancellationToken cancellationToken) {}
+ public Task<List<ImapMessage>> ToListAsync(CancellationToken cancellationToken = default) {}
public override string ToString() {}
}
public class ImapMessageStatusChangedEventArgs : EventArgs {
- public ImapMessageStatusChangedEventArgs(ImapMessage[] messages) {}
+ public ImapMessageStatusChangedEventArgs(IReadOnlyList<ImapMessage> messages) {}
- public ImapMessage[] Messages { get; }
+ public IReadOnlyList<ImapMessage> Messages { get; }
}
public class ImapMessageThread {
- public ReadOnlyCollection<ImapMessageThread> Children { get; }
+ 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() {}
- public bool Wait(int millisecondsTimeout) {}
+ public bool Wait(int millisecondsTimeout = -1) {}
}
- public IImapMessageFlagSet ApplicableFlags { get; }
+ 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 IImapMessageFlagSet PermanentFlags { 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) {}
- public ImapMessage GetMessageBySequence(long sequence, ImapMessageFetchAttributeOptions options) {}
- public Task<ImapMessage> GetMessageBySequenceAsync(long sequence) {}
- public Task<ImapMessage> GetMessageBySequenceAsync(long sequence, ImapMessageFetchAttributeOptions options) {}
- public ImapMessage GetMessageByUid(long uid) {}
- public ImapMessage GetMessageByUid(long uid, ImapMessageFetchAttributeOptions options) {}
- public Task<ImapMessage> GetMessageByUidAsync(long uid) {}
- public Task<ImapMessage> GetMessageByUidAsync(long uid, ImapMessageFetchAttributeOptions options) {}
- public ImapMessage GetMessageFirstUnseen() {}
- public ImapMessage GetMessageFirstUnseen(ImapMessageFetchAttributeOptions options) {}
- public Task<ImapMessage> GetMessageFirstUnseenAsync() {}
- public Task<ImapMessage> GetMessageFirstUnseenAsync(ImapMessageFetchAttributeOptions options) {}
- public ImapMessageQuery GetMessages() {}
- public ImapMessageQuery GetMessages(IEnumerable<long> uids) {}
- public ImapMessageQuery GetMessages(IEnumerable<long> uids, ImapMessageFetchAttributeOptions options) {}
- public ImapMessageQuery GetMessages(ImapMessageFetchAttributeOptions options) {}
+ 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) {}
- public ImapMessageQuery GetMessages(ImapSearchCriteria searchCriteria, Encoding encoding) {}
- public ImapMessageQuery GetMessages(ImapSearchCriteria searchCriteria, Encoding encoding, ImapMessageFetchAttributeOptions options) {}
+ 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) {}
- public ImapMessageQuery GetMessagesGmailSearch(string gmailSearchQuery, ImapMessageFetchAttributeOptions options) {}
- public ImapMessageQuery GetMessagesNew() {}
- public ImapMessageQuery GetMessagesNew(ImapMessageFetchAttributeOptions options) {}
- public ImapMessageQuery GetMessagesRecent() {}
- public ImapMessageQuery GetMessagesRecent(ImapMessageFetchAttributeOptions options) {}
- public ImapMessageQuery GetMessagesUnseen() {}
- public ImapMessageQuery GetMessagesUnseen(ImapMessageFetchAttributeOptions options) {}
- public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder) {}
- public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapMessageFetchAttributeOptions options) {}
- public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria) {}
- public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, Encoding encoding) {}
- public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, Encoding encoding, ImapMessageFetchAttributeOptions options) {}
+ 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) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public ImapMessageQuery GetSortedMessages(ImapSortCriteria sortOrder, ImapSearchCriteria searchCriteria, ImapMessageFetchAttributeOptions options) {}
- public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm) {}
- public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm, ImapMessageFetchAttributeOptions options) {}
- public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria) {}
- public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, Encoding encoding) {}
- public ImapMessageThread GetThreadedMessages(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, Encoding encoding, 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) {}
- public Task<ImapMessageThread> GetThreadedMessagesAsync(ImapThreadingAlgorithm threadingAlgorithm, ImapMessageFetchAttributeOptions options) {}
- public Task<ImapMessageThread> GetThreadedMessagesAsync(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria) {}
- public Task<ImapMessageThread> GetThreadedMessagesAsync(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, Encoding encoding) {}
- public Task<ImapMessageThread> GetThreadedMessagesAsync(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchCriteria, Encoding encoding, 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) {}
- public void Idle(int millisecondsTimeout, int millisecondsPollingInterval) {}
+ 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) {}
- public override Task<ImapOpenMailbox> OpenAsync(bool asReadOnly) {}
+ 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 void RefreshCore(bool reretrieveMailboxFlags) {}
- public ImapOpenMailbox.WatchMailboxContext StartIdle() {}
public ImapOpenMailbox.WatchMailboxContext StartIdle(TimeSpan pollingInterval) {}
- public ImapOpenMailbox.WatchMailboxContext StartIdle(int millisecondsPollingInterval) {}
- public ImapOpenMailbox.WatchMailboxContext StartWaitForMessageArrival() {}
- public ImapOpenMailbox.WatchMailboxContext StartWaitForMessageArrival(ImapMessageFetchAttributeOptions fetchAttributeOptions) {}
+ 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) {}
- public ImapOpenMailbox.WatchMailboxContext StartWaitForMessageArrival(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) {}
- public ImapMessageQuery WaitForMessageArrival(TimeSpan timeout, ImapMessageFetchAttributeOptions fetchAttributeOptions) {}
+ 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) {}
- public ImapMessageQuery WaitForMessageArrival(int millisecondsTimeout) {}
- public ImapMessageQuery WaitForMessageArrival(int millisecondsTimeout, ImapMessageFetchAttributeOptions fetchAttributeOptions) {}
+ 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) {}
+ 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 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 interface IImapExtension {
- IEnumerable<ImapCapability> RequiredCapabilities { get; }
- }
-
- public interface IImapMailboxFlagSet : ISet<ImapMailboxFlag> {
- bool Contains(string @value);
- }
-
- public interface IImapMessageFlagSet : ISet<ImapMessageFlag> {
- bool ContainNonApplicableFlags { get; }
-
- bool Contains(string @value);
- IImapMessageFlagSet GetNonApplicableFlagsRemoved();
- }
-
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,
- IImapExtension
+ IEquatable<ImapAuthenticationMechanism>
{
- public static readonly ImapStringEnumSet<ImapAuthenticationMechanism> AllMechanisms; // = "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 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) {}
- public ImapAuthenticationMechanism(string mechanismName, ImapCapability requiredCapability) {}
+ public ImapAuthenticationMechanism(string mechanismName, ImapCapability requiredCapability = null) {}
+ public static IReadOnlyStringSet<ImapAuthenticationMechanism> AllMechanisms { get; }
public IEnumerable<ImapCapability> RequiredCapabilities { get; }
- public static ImapAuthenticationMechanism GetKnownOrCreate(string mechanismName) {}
+ 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 class ImapCapability : ImapStringEnum {
+ public sealed class ImapCapability :
+ ImapStringEnum,
+ IEquatable<ImapCapability>
+ {
public static readonly ImapCapability Acl; // = "ACL"
- public static readonly ImapCapabilitySet AllCapabilities; // = "QUOTA, LITERAL+, IDLE, MAILBOX-REFERRALS, LOGIN-REFERRALS, NAMESPACE, STARTTLS, LOGINDISABLED, ID, CHILDREN, IMAP4rev1, MULTIAPPEND, BINARY, UNSELECT, ACL, UIDPLUS, URLAUTH, CATENATE, CONDSTORE, ESEARCH, SASL-IR, COMPRESS=DEFLATE, WITHIN, ENABLE, QRESYNC, SEARCHRES, I18NLEVEL=1, I18NLEVEL=2, LANGUAGE, SORT, THREAD=ORDEREDSUBJECT, THREAD=REFERENCES, ANNOTATE-EXPERIMENT-1, LIST-EXTENDED, CONVERT, CONTEXT=SEARCH, CONTEXT=SORT, ESORT, METADATA, METADATA-SERVER, NOTIFY, FILTERS, URLAUTH=BINARY, UTF8=ALL, UTF8=APPEND, UTF8=USER, LIST-STATUS, SORT=DISPLAY, SPECIAL-USE, CREATE-SPECIAL-USE, SEARCH=FUZZY, MULTISEARCH, MOVE, UTF8=ACCEPT, UTF8=ONLY, IMAP4, XLIST, X-GM-EXT-1, XYZZY, SCAN, X-NETSCAPE, AUTH=KERBEROS_V4, AUTH=CRAM-MD5, AUTH=OTP, AUTH=SKEY, AUTH=PLAIN, AUTH=SECURID, AUTH=DIGEST-MD5, AUTH=9798-U-RSA-SHA1-ENC, AUTH=9798-M-RSA-SHA1-ENC, AUTH=9798-U-DSA-SHA1, AUTH=9798-M-DSA-SHA1, AUTH=9798-U-ECDSA-SHA1, AUTH=9798-M-ECDSA-SHA1, AUTH=EXTERNAL, AUTH=ANONYMOUS, AUTH=GSSAPI, AUTH=KERBEROS_V5, AUTH=NTLM, AUTH=LOGIN"
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 class ImapCapabilitySet : ImapStringEnumSet<ImapCapability> {
- public static readonly ImapCapabilitySet ReadOnlyEmpty; // = ""
+ public static IReadOnlyStringSet<ImapCapability> AllCapabilities { get; }
- public ImapCapabilitySet() {}
- public ImapCapabilitySet(IEnumerable<ImapCapability> caps) {}
- public ImapCapabilitySet(bool readOnly, IEnumerable<ImapCapability> caps) {}
+ 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 bool IsCapable(IImapExtension extension) {}
+ public static class ImapCapabilitySetExtensions {
+ public static bool IsCapable(this IReadOnlyStringSet<ImapCapability> capabilities, ImapDataItems feature) {}
+ public static bool IsCapable(this IReadOnlyStringSet<ImapCapability> capabilities, ImapStringEnum feature) {}
}
+ [Serializable]
public sealed class ImapCollationAlgorithm :
ImapStringEnum,
- IImapExtension
+ IEquatable<ImapCollationAlgorithm>
{
- public static readonly ImapStringEnumSet<ImapCollationAlgorithm> AllAlgorithms; // = "default, i;ascii-numeric, i;ascii-casemap, i;octet, i;unicode-casemap"
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) {}
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
- }
-
- public abstract class ImapCombinableDataItem :
- ImapString,
- IEquatable<ImapCombinableDataItem>
- {
- protected ImapCombinableDataItem(params ImapString[] items) {}
-
- protected ImapString[] Items { get; }
+ public static IReadOnlyStringSet<ImapCollationAlgorithm> AllAlgorithms { get; }
- public virtual bool ContainsOneOf(ImapCombinableDataItem combinable) {}
- public override bool Equals(ImapString other) {}
+ public bool Equals(ImapCollationAlgorithm other) {}
public override bool Equals(object obj) {}
- public override bool Equals(string other) {}
- public virtual bool Equals(ImapCombinableDataItem other) {}
- protected abstract ImapStringList GetCombined();
- protected static ImapString[] GetCombinedItems(ImapCombinableDataItem x, ImapCombinableDataItem y) {}
- protected static ImapString[] GetCombinedItems(ImapString[] x, ImapString[] y) {}
public override int GetHashCode() {}
- protected ImapParenthesizedString ToParenthesizedString() {}
- public override string ToString() {}
- protected ImapStringList ToStringList() {}
- public virtual void Traverse(Action<ImapString> action) {}
+ 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,
- IImapExtension
+ IEquatable<ImapCompressionMechanism>
{
- public static readonly ImapStringEnumSet<ImapCompressionMechanism> AllMechanisms; // = "DEFLATE"
public static readonly ImapCompressionMechanism Deflate; // = "DEFLATE"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
+ 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 DateTimeOffset FromDateTimeString(string dateTime) {}
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, Exception innerException) {}
public ImapErrorResponseException(string message, ImapCommandResult result) {}
public ImapCommandResult Result { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
- public class ImapFetchDataItem :
- ImapCombinableDataItem,
- IImapExtension
- {
- public static readonly ImapFetchDataItem All; // = "ALL"
- public static readonly ImapFetchDataItem Body; // = "(BODY)"
- public static readonly ImapFetchDataItem BodyStructure; // = "(BODYSTRUCTURE)"
- public static readonly ImapFetchDataItem Envelope; // = "(ENVELOPE)"
- public static readonly ImapFetchDataItem Fast; // = "FAST"
- public static readonly ImapFetchDataItem Flags; // = "(FLAGS)"
- public static readonly ImapFetchDataItem Full; // = "FULL"
- public static readonly ImapFetchDataItem InternalDate; // = "(INTERNALDATE)"
- public static readonly ImapFetchDataItem ModSeq; // = "(MODSEQ)"
- public static readonly ImapFetchDataItem Rfc822; // = "(RFC822)"
- public static readonly ImapFetchDataItem Rfc822Header; // = "(RFC822.HEADER)"
- public static readonly ImapFetchDataItem Rfc822Size; // = "(RFC822.SIZE)"
- public static readonly ImapFetchDataItem Rfc822Text; // = "(RFC822.TEXT)"
- public static readonly ImapFetchDataItem Uid; // = "(UID)"
-
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
-
- public static ImapFetchDataItem Binary(bool peek, string sectionBinary) {}
- public static ImapFetchDataItem Binary(bool peek, string sectionBinary, ImapFetchRange? @partial) {}
- public static ImapFetchDataItem Binary(bool peek, string sectionBinary, long partialStart, long partialLength) {}
- public static ImapFetchDataItem Binary(string sectionBinary) {}
- public static ImapFetchDataItem Binary(string sectionBinary, ImapFetchRange? @partial) {}
- public static ImapFetchDataItem Binary(string sectionBinary, long partialStart, long partialLength) {}
- public static ImapFetchDataItem BinaryPeek(string sectionBinary) {}
- public static ImapFetchDataItem BinaryPeek(string sectionBinary, ImapFetchRange? @partial) {}
- public static ImapFetchDataItem BinaryPeek(string sectionBinary, long partialStart, long partialLength) {}
- public static ImapFetchDataItem BinarySize(string sectionBinary) {}
- public static ImapFetchDataItem BodyPeek() {}
- public static ImapFetchDataItem BodyPeek(ImapFetchRange? @partial) {}
- public static ImapFetchDataItem BodyPeek(long partialStart, long partialLength) {}
- public static ImapFetchDataItem BodyPeek(string section) {}
- public static ImapFetchDataItem BodyPeek(string section, ImapFetchRange? @partial) {}
- public static ImapFetchDataItem BodyPeek(string section, long partialStart, long partialLength) {}
- public static ImapFetchDataItem BodyText() {}
- public static ImapFetchDataItem BodyText(ImapFetchRange? @partial) {}
- public static ImapFetchDataItem BodyText(bool peek) {}
- public static ImapFetchDataItem BodyText(bool peek, ImapFetchRange? @partial) {}
- public static ImapFetchDataItem BodyText(bool peek, long partialStart, long partialLength) {}
- public static ImapFetchDataItem BodyText(bool peek, string section) {}
- public static ImapFetchDataItem BodyText(bool peek, string section, ImapFetchRange? @partial) {}
- public static ImapFetchDataItem BodyText(bool peek, string section, long partialStart, long partialLength) {}
- public static ImapFetchDataItem BodyText(long partialStart, long partialLength) {}
- public static ImapFetchDataItem BodyText(string section) {}
- public static ImapFetchDataItem BodyText(string section, ImapFetchRange? @partial) {}
- public static ImapFetchDataItem BodyText(string section, long partialStart, long partialLength) {}
- public static ImapFetchDataItem Combine(ImapFetchDataItem x, ImapFetchDataItem y) {}
- public ImapFetchDataItem CombineWith(ImapFetchDataItem dataItem) {}
- public static ImapFetchDataItem FromMacro(ImapFetchDataItemMacro macro) {}
- public static ImapFetchDataItem FromUri(Uri uri) {}
- protected override ImapStringList GetCombined() {}
- public static ImapFetchDataItem operator + (ImapFetchDataItem x, ImapFetchDataItem y) {}
+ 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, long partialStart, long partialLength) {}
+ public static ImapFetchDataItems Binary(string sectionBinary) {}
+ public static ImapFetchDataItems Binary(string sectionBinary, ImapFetchRange? @partial) {}
+ 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, long partialStart, long partialLength) {}
+ public static ImapFetchDataItems BinarySize(string sectionBinary) {}
+ public static ImapFetchDataItems BodyPeek() {}
+ public static ImapFetchDataItems BodyPeek(ImapFetchRange? @partial) {}
+ 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, long partialStart, long partialLength) {}
+ public static ImapFetchDataItems BodyText() {}
+ public static ImapFetchDataItems BodyText(ImapFetchRange? @partial) {}
+ public static ImapFetchDataItems BodyText(bool peek) {}
+ public static ImapFetchDataItems BodyText(bool peek, ImapFetchRange? @partial) {}
+ 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, 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, 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 : ImapCombinableDataItem {
+ 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) {}
- protected override ImapStringList GetCombined() {}
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(ImapCapability[] requiredCapabilities) {}
public ImapIncapableException(string message) {}
+ public ImapIncapableException(string message, IEnumerable<ImapCapability> requiredCapabilities) {}
public ImapIncapableException(string message, ImapCapability requiredCapability) {}
- public ImapIncapableException(string message, ImapCapability[] requiredCapabilities) {}
- public ImapCapability[] RequiredCapabilities { get; }
+ 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 :
- ImapCombinableDataItem,
- IImapExtension
- {
+ 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)"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
-
public static ImapListReturnOptions Combine(ImapListReturnOptions x, ImapListReturnOptions y) {}
public ImapListReturnOptions CombineWith(ImapListReturnOptions other) {}
- protected override ImapStringList GetCombined() {}
- public static ImapListReturnOptions StatusDataItems(ImapStatusDataItem statusDataItem) {}
+ public static ImapListReturnOptions StatusDataItems(ImapStatusDataItems statusDataItems) {}
public static ImapListReturnOptions operator + (ImapListReturnOptions x, ImapListReturnOptions y) {}
}
- public sealed class ImapListSelectionOptions :
- ImapCombinableDataItem,
- IImapExtension
- {
+ 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)"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
-
public static ImapListSelectionOptions Combine(ImapListSelectionOptions x, ImapListSelectionOptions y) {}
public ImapListSelectionOptions CombineWith(ImapListSelectionOptions other) {}
- protected override ImapStringList GetCombined() {}
public static ImapListSelectionOptions operator + (ImapListSelectionOptions x, ImapListSelectionOptions y) {}
}
+ [Serializable]
public sealed class ImapMailboxFlag :
ImapStringEnum,
- IImapExtension
+ IEquatable<ImapMailboxFlag>
{
public static readonly ImapMailboxFlag All; // = "\All"
- public static readonly ImapMailboxFlagSet AllFlags; // = "\Marked, \Unmarked, \Noinferiors, \Noselect, \HasChildren, \HasNoChildren, \NonExistent, \Subscribed, \Remote, \All, \Archive, \Drafts, \Flagged, \Junk, \Sent, \Trash"
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 readonly ImapMailboxFlagSet UseFlags; // = "\All, \Archive, \Drafts, \Flagged, \Junk, \Sent, \Trash"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
- }
+ public static IReadOnlyStringSet<ImapMailboxFlag> AllFlags { get; }
+ public static IReadOnlyStringSet<ImapMailboxFlag> UseFlags { get; }
- public class ImapMailboxFlagSet :
- ImapStringEnumSet<ImapMailboxFlag>,
- IImapMailboxFlagSet
- {
- public static readonly ImapMailboxFlagSet ReadOnlyEmpty; // = ""
+ 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 ImapMailboxFlagSet() {}
- public ImapMailboxFlagSet(IEnumerable<ImapMailboxFlag> flags) {}
+ public static class ImapMailboxNames {
+ public static readonly IEqualityComparer<string> EqualityComparer; // = "Smdn.Net.Imap4.Protocol.ImapMailboxNames+MailboxNameEqualityComparer"
+ public const string Inbox = "INBOX";
- public ImapMailboxFlagSet AsReadOnly() {}
- bool IImapMailboxFlagSet.Contains(string @value) {}
+ public static bool IsInbox(string mailbox) {}
}
+ [Serializable]
public sealed class ImapMessageFlag :
ImapStringEnum,
- IImapExtension
+ IEquatable<ImapMessageFlag>
{
- public static readonly ImapMessageFlagSet AllFlags; // = "\*, \Seen, \Answered, \Flagged, \Deleted, \Draft, \Recent"
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 ImapMessageFlagSet FetchFlags; // = "\Answered, \Flagged, \Deleted, \Seen, \Draft, \Recent"
public static readonly ImapMessageFlag Flagged; // = "\Flagged"
- public static readonly ImapMessageFlagSet NonApplicableFlags; // = "\Recent, \*"
- public static readonly ImapMessageFlagSet PermittedFlags; // = "\Answered, \Flagged, \Deleted, \Seen, \Draft, \*"
public static readonly ImapMessageFlag Recent; // = "\Recent"
public static readonly ImapMessageFlag Seen; // = "\Seen"
- public ImapMessageFlag(string keyword) {}
- public ImapMessageFlag(string keyword, ImapCapability requiredCapability) {}
+ public ImapMessageFlag(string keyword, ImapCapability requiredCapability = null) {}
+ public static IReadOnlyStringSet<ImapMessageFlag> AllFlags { get; }
+ public static IReadOnlyStringSet<ImapMessageFlag> FetchFlags { get; }
public bool IsSystemFlag { get; }
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { 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 class ImapMessageFlagSet :
- ImapStringEnumSet<ImapMessageFlag>,
- IImapMessageFlagSet
- {
- public static readonly ImapMessageFlagSet ReadOnlyEmpty; // = ""
-
- public ImapMessageFlagSet() {}
- public ImapMessageFlagSet(IEnumerable<ImapMessageFlag> flags) {}
- public ImapMessageFlagSet(params ImapMessageFlag[] flags) {}
- public ImapMessageFlagSet(string[] keywords, params ImapMessageFlag[] flags) {}
-
- public bool ContainNonApplicableFlags { get; }
-
- public ImapMessageFlagSet AsReadOnly() {}
- public IImapMessageFlagSet GetNonApplicableFlagsRemoved() {}
- bool IImapMessageFlagSet.Contains(string @value) {}
+ 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) {}
}
- public static class ImapOctets {
- public const byte Asterisk = 42;
- public const byte BackSlash = 92;
- public const byte CloseBrace = 125;
- public const byte CloseBracket = 93;
- public const byte CloseParen = 41;
- public const byte DQuote = 34;
- public const byte OpenBrace = 123;
- public const byte OpenBracket = 91;
- public const byte OpenParen = 40;
- public const byte Plus = 43;
- public const byte Tilde = 126;
-
- public static int IndexOfNonAstringChar(string str) {}
- public static int IndexOfNonAtomChar(string str) {}
- public static int IndexOfNonListChar(string str) {}
- }
-
[Serializable]
public class ImapProtocolViolationException : ImapInvalidOperationException {
protected ImapProtocolViolationException(SerializationInfo info, StreamingContext context) {}
public ImapProtocolViolationException() {}
public ImapProtocolViolationException(string message) {}
}
[Serializable]
public sealed class ImapResponseCode :
ImapStringEnum,
IEquatable<ImapResponseCode>
{
public static readonly ImapResponseCode Alert; // = "ALERT"
- public static readonly ImapStringEnumSet<ImapResponseCode> AllCodes; // = "ALERT, BADCHARSET, CAPABILITY, PARSE, PERMANENTFLAGS, READ-ONLY, READ-WRITE, TRYCREATE, UIDNEXT, UIDVALIDITY, UNSEEN, REFERRAL, UNKNOWN-CTE, APPENDUID, COPYUID, UIDNOTSTICKY, HIGHESTMODSEQ, NOMODSEQ, MODIFIED, COMPRESSIONACTIVE, NOTSAVED, BADCOMPARATOR, METADATA, METADATA LONGENTRIES, METADATA MAXSIZE, METADATA TOOMANY, METADATA NOPRIVATE, UNDEFINED-FILTER, UNAVAILABLE, AUTHENTICATIONFAILED, AUTHORIZATIONFAILED, EXPIRED, PRIVACYREQUIRED, CONTACTADMIN, NOPERM, INUSE, EXPUNGEISSUED, CORRUPTION, SERVERBUG, CLIENTBUG, CANNOT, LIMIT, OVERQUOTA, ALREADYEXISTS, NONEXISTENT, USEATTR"
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 bool HasArguments { get; }
+ public static IReadOnlyStringSet<ImapResponseCode> AllCodes { get; }
public bool Equals(ImapResponseCode other) {}
public override bool Equals(object obj) {}
public override int GetHashCode() {}
- public static ImapResponseCode GetKnownOrCreate(string code) {}
- public static ImapResponseCode GetKnownOrCreate(string code, ImapData subcode) {}
public static bool operator == (ImapResponseCode x, ImapResponseCode y) {}
public static bool operator != (ImapResponseCode x, ImapResponseCode y) {}
}
public sealed class ImapSearchCriteria :
- ImapCombinableDataItem,
- IImapExtension,
+ 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"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
-
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 splitcCharset, out bool containsLiteral, out string charset) {}
- protected override ImapStringList GetCombined() {}
+ 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 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 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 :
- ImapCombinableDataItem,
- IImapExtension
- {
+ 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)"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
-
public static ImapSearchResultOptions Combine(ImapSearchResultOptions x, ImapSearchResultOptions y) {}
public ImapSearchResultOptions CombineWith(ImapSearchResultOptions other) {}
- protected override ImapStringList GetCombined() {}
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 {
- public static readonly ImapStringEnumSet<ImapServerDataResponseType> AllTypes; // = "\u000D\u000A, CAPABILITY, LIST, LSUB, STATUS, SEARCH, FLAGS, EXISTS, RECENT, EXPUNGE, FETCH, QUOTA, QUOTAROOT, NAMESPACE, ID, ESEARCH, ENABLED, THREAD, SORT, LANGUAGE, COMPARATOR, METADATA"
+ public sealed class ImapServerDataResponseType :
+ ImapStringEnum,
+ 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; // = "\u000D\u000A"
+ 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 :
- ImapCombinableDataItem,
- IImapExtension
- {
+ 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)"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
-
public static ImapSortCriteria Combine(ImapSortCriteria x, ImapSortCriteria y) {}
public ImapSortCriteria CombineWith(ImapSortCriteria criteria) {}
- protected override ImapStringList GetCombined() {}
public static ImapSortCriteria operator + (ImapSortCriteria x, ImapSortCriteria y) {}
}
- public sealed class ImapStatusDataItem :
- ImapCombinableDataItem,
- IImapExtension
- {
- public static readonly ImapStatusDataItem HighestModSeq; // = "(HIGHESTMODSEQ)"
- public static readonly ImapStatusDataItem Messages; // = "(MESSAGES)"
- public static readonly ImapStatusDataItem Recent; // = "(RECENT)"
- public static readonly ImapStatusDataItem StandardAll; // = "(MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)"
- public static readonly ImapStatusDataItem UidNext; // = "(UIDNEXT)"
- public static readonly ImapStatusDataItem UidValidity; // = "(UIDVALIDITY)"
- public static readonly ImapStatusDataItem Unseen; // = "(UNSEEN)"
-
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
-
- public static ImapStatusDataItem Combine(ImapStatusDataItem x, ImapStatusDataItem y) {}
- public ImapStatusDataItem CombineWith(ImapStatusDataItem dataItem) {}
- protected override ImapStringList GetCombined() {}
- public static ImapStatusDataItem operator + (ImapStatusDataItem x, ImapStatusDataItem 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 ImapStoreDataItem : ImapCombinableDataItem {
+ public sealed class ImapStoreDataItems : ImapDataItems {
public ImapString ItemName { get; }
- public static ImapStoreDataItem AddFlags(IImapMessageFlagSet flags) {}
- public static ImapStoreDataItem AddFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem AddFlags(string keyword, params string[] keywords) {}
- public static ImapStoreDataItem AddFlags(string[] keywords, ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem AddFlagsSilent(IImapMessageFlagSet flags) {}
- public static ImapStoreDataItem AddFlagsSilent(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem AddFlagsSilent(string keyword, params string[] keywords) {}
- public static ImapStoreDataItem AddFlagsSilent(string[] keywords, ImapMessageFlag[] flags) {}
- protected override ImapStringList GetCombined() {}
- public static ImapStoreDataItem RemoveFlags(IImapMessageFlagSet flags) {}
- public static ImapStoreDataItem RemoveFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem RemoveFlags(string keyword, params string[] keywords) {}
- public static ImapStoreDataItem RemoveFlags(string[] keywords, ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem RemoveFlagsSilent(IImapMessageFlagSet flags) {}
- public static ImapStoreDataItem RemoveFlagsSilent(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem RemoveFlagsSilent(string keyword, params string[] keywords) {}
- public static ImapStoreDataItem RemoveFlagsSilent(string[] keywords, ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem ReplaceFlags(IImapMessageFlagSet flags) {}
- public static ImapStoreDataItem ReplaceFlags(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem ReplaceFlags(string keyword, params string[] keywords) {}
- public static ImapStoreDataItem ReplaceFlags(string[] keywords, ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem ReplaceFlagsSilent(IImapMessageFlagSet flags) {}
- public static ImapStoreDataItem ReplaceFlagsSilent(ImapMessageFlag flag, params ImapMessageFlag[] flags) {}
- public static ImapStoreDataItem ReplaceFlagsSilent(string keyword, params string[] keywords) {}
- public static ImapStoreDataItem ReplaceFlagsSilent(string[] keywords, ImapMessageFlag[] flags) {}
+ 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,
- IImapExtension
+ IEquatable<ImapThreadingAlgorithm>
{
- public static readonly ImapStringEnumSet<ImapThreadingAlgorithm> AllAlgorithms; // = "ORDEREDSUBJECT, REFERENCES"
public static readonly ImapThreadingAlgorithm OrderedSubject; // = "ORDEREDSUBJECT"
public static readonly ImapThreadingAlgorithm References; // = "REFERENCES"
- IEnumerable<ImapCapability> IImapExtension.RequiredCapabilities { get; }
+ 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 {
- IImapMessageFlagSet Flags { get; }
+ IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
DateTimeOffset? InternalDate { get; }
+ long Length { get; }
Stream GetMessageStream();
}
public sealed class ImapAddress {
- public ImapAddress(string name, string atDomainList, string mailbox, string host) {}
-
[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() {}
- public string GetDecodedName(EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
- public MailAddress ToMailAddress() {}
- public MailAddress ToMailAddress(EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
- public static MailAddressCollection ToMailAddressCollection(IEnumerable<ImapAddress> addresses) {}
- public static MailAddressCollection ToMailAddressCollection(IEnumerable<ImapAddress> addresses, EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
+ 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) {}
- public ImapAppendMessage(Stream messageStream, DateTimeOffset internalDate) {}
- public ImapAppendMessage(Stream messageStream, DateTimeOffset internalDate, IImapMessageFlagSet flags) {}
- public ImapAppendMessage(Stream messageStream, IImapMessageFlagSet flags) {}
- public ImapAppendMessage(byte[] message) {}
- public ImapAppendMessage(byte[] message, DateTimeOffset internalDate) {}
- public ImapAppendMessage(byte[] message, DateTimeOffset internalDate, IImapMessageFlagSet flags) {}
- public ImapAppendMessage(byte[] message, IImapMessageFlagSet flags) {}
-
- public ImapMessageFlagSet Flags { get; }
- public DateTimeOffset? InternalDate { get; set; }
- IImapMessageFlagSet IImapAppendMessage.Flags { get; }
+ 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 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 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 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 override string ToString() {}
}
public sealed class ImapEnvelope {
- public ImapEnvelope(string date, string subject, IReadOnlyList<ImapAddress> from, IReadOnlyList<ImapAddress> sender, IReadOnlyList<ImapAddress> replyTo, IReadOnlyList<ImapAddress> to, IReadOnlyList<ImapAddress> cc, IReadOnlyList<ImapAddress> bcc, string inReplyTo, string messageId) {}
-
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() {}
- public DateTimeOffset? GetDecodedDate(bool throwIfMalformed) {}
- public string GetDecodedSubject() {}
- public string GetDecodedSubject(EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
+ 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(IImapMailboxFlagSet nameAttributes, string hierarchyDelimiter, string name) {}
+ public ImapListedMailbox(IReadOnlyStringSet<ImapMailboxFlag> nameAttributes, string hierarchyDelimiter, string name) {}
public ImapListedMailbox.ListExtendedChildInfo ChildInfo { get; }
public string HierarchyDelimiter { get; }
public string Name { get; }
- public IImapMailboxFlagSet NameAttributes { get; }
+ public IReadOnlyStringSet<ImapMailboxFlag> NameAttributes { get; }
public override string ToString() {}
}
[Serializable]
public class ImapMatchedSequenceSet : ImapSequenceSet {
protected ImapMatchedSequenceSet(SerializationInfo info, StreamingContext context) {}
public ImapMatchedSequenceSet(ImapSequenceSet sequenceSet) {}
public ImapMatchedSequenceSet(ImapSequenceSet sequenceSet, ulong highestModSeq) {}
public override long ConcreteCount { get; }
public long? Count { 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 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 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 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) {}
public static string JoinEntryName(string hierarchicalEntryName, params string[] hierarchicalEntryNames) {}
public static string[] SplitEntryName(string entryName) {}
}
public sealed class ImapNamespace : ICloneable {
- public ImapNamespace() {}
- public ImapNamespace(IReadOnlyList<ImapNamespaceDesc> personalNamespaces, IReadOnlyList<ImapNamespaceDesc> otherUsersNamespaces, IReadOnlyList<ImapNamespaceDesc> sharedNamespaces) {}
+ public ImapNamespace(IReadOnlyList<ImapNamespaceDesc> personalNamespaces = null, IReadOnlyList<ImapNamespaceDesc> otherUsersNamespaces = null, IReadOnlyList<ImapNamespaceDesc> sharedNamespaces = null) {}
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) {}
- public ImapNamespaceDesc(string prefix, string hierarchyDelimiter) {}
- public ImapNamespaceDesc(string prefix, string hierarchyDelimiter, IReadOnlyDictionary<string, string[]> extensions) {}
+ public ImapNamespaceDesc(string prefix, string hierarchyDelimiter = null, IReadOnlyDictionary<string, IReadOnlyList<string>> extensions = null) {}
- public IReadOnlyDictionary<string, string[]> Extensions { get; }
+ 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 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 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 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 override string ToString() {}
public void Traverse(Action<ImapThreadList> action) {}
}
public struct ImapFetchRange :
IEquatable<ImapFetchRange>,
IFormattable
{
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 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) {}
}
}
namespace Smdn.Net.Imap4.Protocol.DataStructures.BodyStructures {
- public interface IImapBodyStructure :
- IEnumerable<IImapBodyStructure>,
- IImapUrl
- {
+ public interface IImapBodyStructure : IImapUrl {
bool HasEncapsulatedMessage { get; }
bool IsMultiPart { get; }
MimeType MediaType { get; }
IImapBodyStructure ParentStructure { get; }
string Section { get; }
}
- public interface IImapBodyStructureExtension : IImapBodyStructure {
+ public interface IImapExtendedBodyStructure : IImapBodyStructure {
ImapBodyDisposition Disposition { get; }
IReadOnlyList<ImapData> Extensions { get; }
IReadOnlyList<string> Languages { get; }
Uri Location { get; }
}
public sealed class ImapBodyDisposition {
- public ImapBodyDisposition(string type, IReadOnlyDictionary<string, string> parameters) {}
-
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) {}
- public static string GetContentFileName(this IImapBodyStructure bodyStructure, EncodingSelectionCallback selectFallbackEncoding, bool throwIfMalformedOrUnsupported) {}
+ 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 class ImapExtendedMessageRfc822BodyStructure :
+ public sealed class ImapExtendedMessageRfc822BodyStructure :
ImapMessageRfc822BodyStructure,
- IImapBodyStructureExtension
+ IImapExtendedBodyStructure
{
- public ImapExtendedMessageRfc822BodyStructure(ImapMessageRfc822BodyStructure baseStructure, string md5, ImapBodyDisposition disposition, IReadOnlyList<string> languages, Uri location, IReadOnlyList<ImapData> extensions) {}
-
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 ImapExtendedMultiPartBodyStructure :
+ public sealed class ImapExtendedMultiPartBodyStructure :
ImapMultiPartBodyStructure,
- IImapBodyStructureExtension
+ IImapExtendedBodyStructure
{
- public ImapExtendedMultiPartBodyStructure(ImapMultiPartBodyStructure baseStructure, IReadOnlyDictionary<string, string> parameters, ImapBodyDisposition disposition, IReadOnlyList<string> languages, Uri location, IReadOnlyList<ImapData> extensions) {}
-
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 class ImapExtendedSinglePartBodyStructure :
+ public sealed class ImapExtendedSinglePartBodyStructure :
ImapSinglePartBodyStructure,
- IImapBodyStructureExtension
+ IImapExtendedBodyStructure
{
- public ImapExtendedSinglePartBodyStructure(ImapSinglePartBodyStructure baseStructure, string md5, ImapBodyDisposition disposition, IReadOnlyList<string> languages, Uri location, IReadOnlyList<ImapData> extensions) {}
-
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 {
- protected ImapMessageRfc822BodyStructure(ImapMessageRfc822BodyStructure baseStructure) {}
- public ImapMessageRfc822BodyStructure(string section, MimeType mediaType, IReadOnlyDictionary<string, string> parameters, string id, string description, string encoding, long size, ImapEnvelope envelope, IImapBodyStructure bodyStructure, long lineCount) {}
-
+ [Obsolete("refer EncapsulatedMessageStructure instead")]
public IImapBodyStructure BodyStructure { get; }
+ public IImapBodyStructure EncapsulatedMessageStructure { get; }
public ImapEnvelope Envelope { get; }
public override bool HasEncapsulatedMessage { get; }
- public override IEnumerator<IImapBodyStructure> GetEnumerator() {}
- IEnumerator IEnumerable.GetEnumerator() {}
public override string ToString() {}
}
public class ImapMultiPartBodyStructure : IImapBodyStructure {
- protected ImapMultiPartBodyStructure(ImapMultiPartBodyStructure baseStructure) {}
- public ImapMultiPartBodyStructure(string section, IReadOnlyList<IImapBodyStructure> nestedStructures, string subtype) {}
-
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; }
- public IEnumerator<IImapBodyStructure> GetEnumerator() {}
void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
- IEnumerator IEnumerable.GetEnumerator() {}
public override string ToString() {}
}
public class ImapSinglePartBodyStructure : IImapBodyStructure {
- protected ImapSinglePartBodyStructure(ImapSinglePartBodyStructure baseStructure) {}
- public ImapSinglePartBodyStructure(string section, MimeType mediaType, IReadOnlyDictionary<string, string> parameters, string id, string description, string encoding, long size, long lineCount) {}
-
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; }
- public virtual IEnumerator<IImapBodyStructure> GetEnumerator() {}
void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
- IEnumerator IEnumerable.GetEnumerator() {}
public override string ToString() {}
}
}
namespace Smdn.Net.Imap4.Protocol.DataStructures.MessageAttributes {
- public interface IImapMessageAttribute :
- IImapMessageDynamicAttribute,
- IImapMessageStaticAttribute
- {
- long Sequence { get; }
- }
-
- public interface IImapMessageAttributeCollection<TMessageAttribute> where TMessageAttribute : ImapMessageAttributeBase {
- void Add(TMessageAttribute @value);
- TMessageAttribute Find(long sequence);
- }
-
- public interface IImapMessageBody {
- long Sequence { get; }
-
- void CopyBody(string specifier, byte[] buffer, int offset, int count);
- Stream GetBody(string specifier);
- byte[] GetBodyAsByteArray(string specifier);
- string GetBodyAsString(string specifier);
- long? GetBodyLength(string specifier);
+ public interface IImapMessageAttributeCollection<TMessageAttributes> where TMessageAttributes : ImapMessageAttributesBase {
+ void Add(TMessageAttributes @value);
+ TMessageAttributes Find(long sequence);
}
- public interface IImapMessageDynamicAttribute {
- IImapMessageFlagSet Flags { get; }
+ public interface IImapMessageDynamicAttributes {
+ IReadOnlyStringSet<ImapMessageFlag> Flags { get; }
ulong ModSeq { get; }
long Sequence { get; }
}
- public interface IImapMessageStaticAttribute : IImapUrl {
+ 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 ImapMessage :
- ImapMessageBody,
- IImapAppendMessage,
- IImapMessageAttribute
+ public sealed class ImapMessageAttributes :
+ ImapMessageAttributesBase,
+ IImapMessageDynamicAttributes,
+ IImapMessageStaticAttributes,
+ IImapUrl
{
- public long BinarySize { get; }
+ public IReadOnlyCollection<string> BinarySizeSpecifiers { get; }
public IImapBodyStructure BodyStructure { get; }
public ImapEnvelope Envelope { get; }
- public IImapMessageFlagSet Flags { 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 ImapMessageDynamicAttribute GetDynamicAttributeImpl() {}
- public ImapMessageStaticAttribute GetStaticAttributeImpl() {}
- Stream IImapAppendMessage.GetMessageStream() {}
+ public long GetFirstBinarySize() {}
void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
public override string ToString() {}
}
- public sealed class ImapMessageAttribute :
- ImapMessageAttributeBase,
- IImapMessageAttribute
+ 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 long BinarySize { get; }
+ public IReadOnlyCollection<string> BinarySizeSpecifiers { get; }
public IImapBodyStructure BodyStructure { get; }
public ImapEnvelope Envelope { get; }
- public IImapMessageFlagSet Flags { 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 ImapMessageDynamicAttribute GetDynamicAttributeImpl() {}
- public ImapMessageStaticAttribute GetStaticAttributeImpl() {}
+ public long GetFirstBinarySize() {}
+ Stream IImapAppendMessage.GetMessageStream() {}
void IImapUrl.SetBaseUrl(ImapUriBuilder baseUrl) {}
public override string ToString() {}
}
- public abstract class ImapMessageAttributeBase {
- internal protected ImapMessageAttributeBase(long sequence) {}
-
- public long Sequence { get; }
-
- protected IImapUrlSearchQuery GetSequenceNumberSearchCriteria() {}
- }
-
- public class ImapMessageBody :
- ImapMessageAttributeBase,
- IImapMessageBody
- {
- internal protected ImapMessageBody(long sequence) {}
-
- public void CopyBody(string specifier, byte[] buffer, int offset, int count) {}
- public void CopyFirstBody(byte[] buffer, int offset, int count) {}
- public Stream GetBody(string specifier) {}
- public byte[] GetBodyAsByteArray(string specifier) {}
- public string GetBodyAsString(string specifier) {}
- public long? GetBodyLength(string specifier) {}
- public Stream GetFirstBody() {}
- public int GetFirstBody(ref byte[] buffer) {}
- public byte[] GetFirstBodyAsByteArray() {}
- public string GetFirstBodyAsString() {}
- public long GetFirstBodyLength() {}
- public override string ToString() {}
- }
-
- public sealed class ImapMessageDynamicAttribute :
- ImapMessageAttributeBase,
- IImapMessageDynamicAttribute
- {
- public IImapMessageFlagSet Flags { get; }
- public ulong ModSeq { get; }
-
+ public sealed class ImapMessageNullAttributes : ImapMessageBodyAttributes {
public override string ToString() {}
}
- public sealed class ImapMessageStaticAttribute :
- ImapMessageAttributeBase,
- IImapMessageStaticAttribute
+ public sealed class ImapMessageStaticAttributes :
+ ImapMessageAttributesBase,
+ IImapMessageStaticAttributes,
+ IImapUrl
{
- public long BinarySize { get; }
+ 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 delegate bool ImapKeepIdleCallback(object state, ImapResponse receivedResponse);
-
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; }
- string[] UsingSaslMechanisms { get; }
+ IReadOnlyList<string> UsingSaslMechanisms { get; }
}
public enum ImapSessionState : int {
Authenticated = 2,
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) {}
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 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(ImapFetchDataItem fetchDataItem, out IImapMessageAttribute messageAttr) {}
+ internal protected virtual ImapCommandResult Prepare(ImapFetchDataItems fetchDataItems, out ImapMessageAttributes messageAttributes) {}
public override int Read(byte[] dest, 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 ImapLoginReferralException(string message, Uri referToUri) {}
public Uri ReferToUri { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public class ImapMailboxReferralException : ImapReferralException {
protected ImapMailboxReferralException(SerializationInfo info, StreamingContext context) {}
- public ImapMailboxReferralException(string message, Uri[] referrals) {}
- public Uri[] Referrals { get; }
+ public IReadOnlyList<Uri> Referrals { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
public sealed class ImapMailboxStatus : IImapUrl {
- public IImapMessageFlagSet ApplicableFlags { get; }
+ public IReadOnlyStringSet<ImapMessageFlag> ApplicableFlags { get; }
public long ExistsMessage { get; }
public long FirstUnseen { get; }
- public IImapMailboxFlagSet Flags { 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 IImapMessageFlagSet PermanentFlags { 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 string GetChildName(string childName) {}
public bool NameEquals(ImapMailboxStatus other) {}
public bool NameEquals(string otherMailboxName) {}
- public static bool NameEquals(string mailboxNameX, string mailboxNameY) {}
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 : IDisposable {
+ 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 createAuthenticatedStreamCallback = null) {}
+ public ImapSession(string host, int port = 143, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool handlesReferralAsException = false, UpgradeConnectionStreamCallback createAuthenticatedStream = null) {}
public ImapCollationAlgorithm ActiveComparator { get; }
public Uri Authority { get; }
- public IConnectionInfo ConnectionInfo { 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 ImapCapabilitySet ServerCapabilities { get; }
+ 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(IImapAppendMessage message, ImapMailboxStatus mailbox) {}
+ 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) {}
public ImapCommandResult Append(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids) {}
- public ImapCommandResult Append(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult Append(IImapAppendMessage message, string mailboxName, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult AppendBinary(IImapAppendMessage message, ImapMailboxStatus mailbox) {}
+ 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) {}
public ImapCommandResult AppendBinary(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids) {}
- public ImapCommandResult AppendBinary(IImapAppendMessage message, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult AppendBinary(IImapAppendMessage message, string mailboxName, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult AppendBinaryMultiple(IEnumerable<IImapAppendMessage> messages, ImapMailboxStatus mailbox) {}
- public ImapCommandResult AppendBinaryMultiple(IEnumerable<IImapAppendMessage> messages, ImapMailboxStatus mailbox, out ImapAppendedUidSet appendedUids) {}
- public ImapCommandResult AppendBinaryMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName) {}
- public ImapCommandResult AppendBinaryMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids) {}
- public ImapCommandResult AppendBinaryMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult AppendBinaryMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult AppendMultiple(IEnumerable<IImapAppendMessage> messages, ImapMailboxStatus mailbox) {}
- public ImapCommandResult AppendMultiple(IEnumerable<IImapAppendMessage> messages, ImapMailboxStatus mailbox, out ImapAppendedUidSet appendedUids) {}
- public ImapCommandResult AppendMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName) {}
- public ImapCommandResult AppendMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids) {}
- public ImapCommandResult AppendMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapAppendedUidSet appendedUids, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult AppendMultiple(IEnumerable<IImapAppendMessage> messages, string mailboxName, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult Authenticate(ICredentialsByHost credentials, ImapAuthenticationMechanism authenticationMechanism, bool reissueCapability = false) {}
- public ImapCommandResult Authenticate(ICredentialsByHost credentials, string username, ImapAuthenticationMechanism authenticationMechanism, bool reissueCapability = false, CancellationToken cancellationToken = default) {}
+ 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 ImapCapabilitySet capabilities) {}
+ public ImapCommandResult Capability(out IReadOnlyStringSet<ImapCapability> capabilities) {}
public ImapCommandResult Check() {}
public ImapCommandResult Close() {}
- public ImapCommandResult Comparator() {}
public ImapCommandResult Comparator(ImapCollationAlgorithm comparator, params ImapCollationAlgorithm[] comparators) {}
- public ImapCommandResult Comparator(out ImapCollationAlgorithm activeComparator) {}
- public ImapCommandResult Comparator(out ImapCollationAlgorithm activeComparator, out ImapCollationAlgorithm[] matchingComparators, ImapCollationAlgorithm comparator, params ImapCollationAlgorithm[] comparators) {}
- public ImapCommandResult Comparator(out ImapCollationAlgorithm[] matchingComparators, 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 Copy(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult Copy(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult Copy(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, ImapMailboxStatus mailbox) {}
- public ImapCommandResult Copy(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, string mailboxName) {}
- public ImapCommandResult Copy(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, string mailboxName, bool tryCreate, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult Copy(ImapSession.CopyMoveCommand command, ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
+ 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 ImapCommandResult Create(string mailboxName) {}
public ImapCommandResult Create(string mailboxName, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult CreateSpecialUse(string mailboxName, IImapMailboxFlagSet useFlags) {}
- public ImapCommandResult CreateSpecialUse(string mailboxName, IImapMailboxFlagSet useFlags, out ImapMailboxStatus createdMailbox) {}
+ 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 ImapCommandResult ESearch(ImapSearchCriteria searchingCriteria, Encoding charset, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult ESearch(ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult ESort(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, Encoding charset, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult ESort(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult Enable(out ImapCapabilitySet enabledCapabilities, params string[] capabilityNames) {}
+ 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 long[] expungedMessages) {}
- public ImapCommandResult Fetch<TMessageAttribute>(ImapSequenceSet sequenceOrUidSet, ImapFetchDataItem messageDataItems) where TMessageAttribute : ImapMessageAttributeBase {}
- public ImapCommandResult Fetch<TMessageAttribute>(ImapSequenceSet sequenceOrUidSet, ImapFetchDataItem messageDataItems, out TMessageAttribute[] messages) where TMessageAttribute : ImapMessageAttributeBase {}
- public ImapCommandResult FetchChangedSince<TMessageAttribute>(ImapSequenceSet sequenceOrUidSet, ImapFetchDataItem messageDataItems, ulong modSeq, out TMessageAttribute[] messages) where TMessageAttribute : ImapMessageAttributeBase {}
- public ImapCommandResult GenericCommand(string command, out ImapServerDataResponse[] dataResponses, params ImapString[] arguments) {}
+ 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 GenericCommand(string command, out IReadOnlyList<ImapServerDataResponse> dataResponses, params ImapString[] arguments) {}
public ImapCommandResult GenericCommand(string command, params ImapString[] arguments) {}
- public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, string entrySpecifier, ImapGetMetadataOptions options, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, string entrySpecifier, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, string[] entrySpecifiers, ImapGetMetadataOptions options, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(ImapMailboxStatus mailbox, string[] entrySpecifiers, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string entrySpecifier, ImapGetMetadataOptions options, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string entrySpecifier, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string mailboxName, string entrySpecifier, ImapGetMetadataOptions options, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string mailboxName, string entrySpecifier, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string mailboxName, string[] entrySpecifiers, ImapGetMetadataOptions options, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string mailboxName, string[] entrySpecifiers, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string[] entrySpecifiers, ImapGetMetadataOptions options, out ImapMetadata[] metadata) {}
- public ImapCommandResult GetMetadata(string[] entrySpecifiers, out ImapMetadata[] metadata) {}
+ 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, ImapQuota[]> quotaRoots) {}
- public ImapCommandResult GetQuotaRoot(string mailboxName, out IReadOnlyDictionary<string, ImapQuota[]> quotaRoots) {}
+ 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(TimeSpan idleTimeout, object state, ImapKeepIdleCallback keepIdleCallback) {}
- public ImapCommandResult Idle(TimeSpan timeout) {}
- public ImapCommandResult Idle(int idleMillisecondsTimeout, object state, ImapKeepIdleCallback keepIdleCallback) {}
- public ImapCommandResult Idle(int millisecondsTimeout) {}
- public ImapCommandResult Idle(object state, ImapKeepIdleCallback keepIdleCallback) {}
+ 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(object keepIdleState, ImapKeepIdleCallback keepIdleCallback) {}
- public Task<ImapCommandResult> IdleAsync(object keepIdleState, ImapKeepIdleCallback keepIdleCallback, CancellationToken stopIdleCancellationToken) {}
- public ImapCommandResult Language() {}
+ 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) {}
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(out string[] supportedLanguageTags) {}
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(out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult List(string mailboxName, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult List(string referenceName, string mailboxName, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult ListExtended(ImapListReturnOptions returnOptions, out ImapMailboxStatus[] mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
- public ImapCommandResult ListExtended(ImapListSelectionOptions selectionOptions, ImapListReturnOptions returnOptions, out ImapMailboxStatus[] mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
- public ImapCommandResult ListExtended(ImapListSelectionOptions selectionOptions, out ImapMailboxStatus[] mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
- public ImapCommandResult ListExtended(out ImapMailboxStatus[] mailboxes, string mailboxNamePattern, params string[] mailboxNamePatterns) {}
- public ImapCommandResult ListExtended(string mailboxNamePattern, ImapListReturnOptions returnOptions, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult ListExtended(string mailboxNamePattern, ImapListSelectionOptions selectionOptions, ImapListReturnOptions returnOptions, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult ListExtended(string mailboxNamePattern, ImapListSelectionOptions selectionOptions, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult ListExtended(string mailboxNamePattern, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult ListExtended(string referenceName, string[] mailboxNamePatterns, ImapListSelectionOptions selectionOptions, ImapListReturnOptions returnOptions, out ImapMailboxStatus[] mailboxes) {}
+ 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, bool reissueCapability = false) {}
- public ImapCommandResult Login(ICredentialsByHost credentials, string username, bool reissueCapability = false) {}
+ public ImapCommandResult Login(ICredentialsByHost credentials, string username = null, bool reissueCapability = false) {}
public ImapCommandResult Logout() {}
public ImapCommandResult Lsub(ImapMailboxStatus mailbox) {}
- public ImapCommandResult Lsub(out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult Lsub(string mailboxName, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult Lsub(string referenceName, string mailboxName, out ImapMailboxStatus[] mailboxes) {}
+ 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 Move(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapCopiedUidSet copiedUids, out ImapMailboxStatus createdMailbox) {}
- public ImapCommandResult Move(ImapSequenceSet sequenceOrUidSet, string mailboxName, out ImapMailboxStatus createdMailbox) {}
+ 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 Namespace() {}
public ImapCommandResult Namespace(out ImapNamespace namespaces) {}
public ImapCommandResult NoOp() {}
- public ImapCommandResult RList(out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult RList(string mailboxName, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult RList(string referenceName, string mailboxName, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult RLsub(out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult RLsub(string mailboxName, out ImapMailboxStatus[] mailboxes) {}
- public ImapCommandResult RLsub(string referenceName, string mailboxName, out ImapMailboxStatus[] mailboxes) {}
+ 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(ImapSearchCriteria searchingCriteria, Encoding charset, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult Search(ImapSearchCriteria searchingCriteria, out ImapMatchedSequenceSet matched) {}
+ 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(ImapMailboxStatus mailbox, params string[] entrySpecifiers) {}
- public ImapCommandResult SetMetadata(params ImapMetadata[] metadata) {}
public ImapCommandResult SetMetadata(string mailboxName, params ImapMetadata[] metadata) {}
- public ImapCommandResult SetMetadata(string mailboxName, params string[] entrySpecifiers) {}
- public ImapCommandResult SetMetadata(string[] entrySpecifiers) {}
+ 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, ImapQuotaResource[] resourceLimits) {}
- public ImapCommandResult SetQuota(string quotaRoot, ImapQuotaResource[] resourceLimits, 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(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, Encoding charset, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult Sort(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult StartTls(UpgradeConnectionStreamCallback createAuthenticatedStreamCallback, bool reissueCapability = false) {}
- public ImapCommandResult Status(ImapMailboxStatus mailbox, ImapStatusDataItem statusDataItem) {}
- public ImapCommandResult Status(string mailboxName, ImapStatusDataItem statusDataItem) {}
- public ImapCommandResult Status(string mailboxName, ImapStatusDataItem statusDataItem, out ImapMailboxStatus statusMailbox) {}
- public ImapCommandResult Status(string mailboxName, ImapStatusDataItem statusDataItem, out ImapStatusAttributes statusAttributes) {}
- public ImapCommandResult Store(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem) {}
- public ImapCommandResult Store(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem, out ImapMessageAttribute[] messageAttributes) {}
- public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem, ulong modSeq) {}
- public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem, ulong modSeq, out ImapMessageAttribute[] messageAttributes) {}
- public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem, ulong modSeq, out ImapMessageAttribute[] messageAttributes, out ImapSequenceSet failedMessageSet) {}
- public ImapCommandResult StoreUnchangedSince(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem, ulong modSeq, out ImapSequenceSet failedMessageSet) {}
+ 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 Subscribe(ImapMailboxStatus mailbox) {}
public ImapCommandResult Subscribe(string mailboxName) {}
void IDisposable.Dispose() {}
- public ImapCommandResult Thread(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, Encoding charset, out ImapThreadList threadList) {}
- public ImapCommandResult Thread(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, out ImapThreadList threadList) {}
+ public ImapCommandResult Thread(out ImapThreadList threadList, ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, Encoding charset = null) {}
public override string ToString() {}
- public ImapCommandResult UidESearch(ImapSearchCriteria searchingCriteria, Encoding charset, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidESearch(ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidESort(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, Encoding charset, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidESort(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, ImapSearchResultOptions resultOptions, out ImapMatchedSequenceSet matched) {}
+ 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 long[] expungedMessages) {}
- public ImapCommandResult UidSearch(ImapSearchCriteria searchingCriteria, Encoding charset, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidSearch(ImapSearchCriteria searchingCriteria, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidSort(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, Encoding charset, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidSort(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidSortPreformatted(ImapSortCriteria sortingCriteria, ImapSearchCriteria searchingCriteria, string charset, out ImapMatchedSequenceSet matched) {}
- public ImapCommandResult UidThread(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, Encoding charset, out ImapThreadList threadList) {}
- public ImapCommandResult UidThread(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, out ImapThreadList threadList) {}
- public ImapCommandResult UidThreadPreformatted(ImapThreadingAlgorithm threadingAlgorithm, ImapSearchCriteria searchingCriteria, string charset, out ImapThreadList threadList) {}
+ public ImapCommandResult UidExpunge(ImapSequenceSet 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(IImapSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken, out ImapSession session) {}
- public static ImapCommandResult CreateSession(IImapSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, out ImapSession session) {}
- public static ImapSession CreateSession(IImapSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken = default) {}
+ 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 {
- public interface IImapLiteralString {
- ImapLiteralOptions Options { get; set; }
-
- Stream GetLiteralStream();
- }
-
[Flags]
public enum ImapLiteralOptions : int {
Default = 0x00000002,
Literal = 0x00000000,
Literal8 = 0x00000010,
Literal8IfCapable = 0x00000020,
LiteralMode = 0x000000f0,
NonSynchronizing = 0x00000001,
NonSynchronizingIfCapable = 0x00000002,
SynchronizationMode = 0x0000000f,
Synchronizing = 0x00000000,
}
- public class ImapLiteralStream :
- ImapString,
- IImapLiteralString
- {
- public ImapLiteralStream(Stream stream) {}
- public ImapLiteralStream(Stream stream, ImapLiteralOptions options) {}
-
- public ImapLiteralOptions Options { get; set; }
-
- Stream IImapLiteralString.GetLiteralStream() {}
- public override string ToString() {}
- }
-
- public class ImapLiteralString :
- ImapString,
- IImapLiteralString
- {
- public ImapLiteralString(string val) {}
- public ImapLiteralString(string val, Encoding charset) {}
- public ImapLiteralString(string val, Encoding charset, ImapLiteralOptions options) {}
+ public abstract class ImapLiteralString : ImapString {
+ protected ImapLiteralString(ImapLiteralOptions options) {}
- public Encoding Charset { get; set; }
- public ImapLiteralOptions Options { get; set; }
+ internal protected abstract long Length { get; }
- Stream IImapLiteralString.GetLiteralStream() {}
+ 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 class ImapMailboxNameString : ImapString {
- public static ImapMailboxNameString CreateListMailboxName(string mailboxName) {}
- public static ImapMailboxNameString CreateMailboxName(string mailboxName) {}
- public static ImapMailboxNameString CreateMailboxNameNonEmpty(string mailboxName) {}
- internal protected override string GetEscaped() {}
- }
-
- public class ImapNilString : ImapString {
- public static readonly ImapNilString Nil; // = "NIL"
- }
-
- public class ImapParenthesizedString : ImapStringList {
- public ImapParenthesizedString(params ImapString[] values) {}
- public ImapParenthesizedString(params string[] values) {}
- public ImapParenthesizedString(string val) {}
- }
-
- public class ImapPreformattedString : ImapString {
- public ImapPreformattedString(byte[] octets) {}
-
- public byte[] Octets { get; }
-
- public override string ToString() {}
+ public static class ImapNilString {
+ public static readonly ImapString Nil; // = "NIL"
}
- public class ImapQuotedString : ImapString {
- public static readonly ImapQuotedString Empty; // = "\"\""
+ public static class ImapQuotedString {
+ public static readonly ImapString Empty; // = "\"\""
- public ImapQuotedString(string val) {}
-
- internal protected override string GetEscaped() {}
- public override string ToString() {}
+ public static ImapString Create(string @value) {}
}
[Serializable]
- public class ImapString :
+ public abstract class ImapString :
IEquatable<ImapString>,
IEquatable<string>
{
protected ImapString() {}
- public ImapString(string val) {}
-
- public string Value { get; }
public override bool Equals(object obj) {}
public virtual bool Equals(ImapString other) {}
public virtual bool Equals(string other) {}
- internal protected virtual string GetEscaped() {}
public override int GetHashCode() {}
public override string ToString() {}
public static implicit operator ImapString(string str) {}
}
[Serializable]
public abstract class ImapStringEnum :
ImapString,
- IEquatable<ImapStringEnum>,
IStringEnum
{
protected ImapStringEnum(string @value) {}
- string IStringEnum.Value { get; }
+ public string Value { get; }
- protected static ImapStringEnumSet<TStringEnum> CreateDefinedConstantsSet<TStringEnum>() where TStringEnum : ImapStringEnum {}
public bool Equals(IStringEnum other) {}
- public override bool Equals(ImapString other) {}
public override bool Equals(object obj) {}
public override bool Equals(string other) {}
- public virtual bool Equals(ImapStringEnum other) {}
- protected static IEnumerable<TStringEnum> GetDefinedConstants<TStringEnum>() where TStringEnum : ImapStringEnum {}
public override int GetHashCode() {}
- public static bool operator == (ImapStringEnum x, ImapStringEnum y) {}
- public static bool operator != (ImapStringEnum x, ImapStringEnum y) {}
- }
-
- public class ImapStringEnumSet<TStringEnum> : StringEnumSet<TStringEnum> where TStringEnum : ImapStringEnum {
- public ImapStringEnumSet() {}
- public ImapStringEnumSet(IEnumerable<TStringEnum> values) {}
+ public override string ToString() {}
}
public class ImapStringList :
ImapString,
- IEnumerable<ImapString>
+ IReadOnlyCollection<ImapString>
{
- protected ImapStringList(ImapString[] values, bool parenthesize) {}
- protected ImapStringList(string[] values, bool parenthesize) {}
- public ImapStringList(params ImapString[] values) {}
- public ImapStringList(params string[] values) {}
- public ImapStringList(string val) {}
-
- public int Count { get; }
- public ImapString this[int index] { get; set; }
+ 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() {}
- public void Traverse(Action<ImapString> action) {}
}
}
namespace Smdn.Net.Imap4.Protocol.Transmission {
- public enum ImapCommandResultCode : int {
- Bad = 500,
- Bye = 501,
- ConnectionError = 450,
- Default = 999,
- InternalError = 401,
- No = 400,
- Ok = 200,
- PreAuth = 201,
- RequestDone = 250,
- RequestError = 402,
- ResponseError = 502,
- SocketTimeout = 408,
- UpgradeError = 426,
- }
-
public enum ImapDataFormat : int {
- List = 1,
- Nil = 2,
- None = 3,
- Text = 0,
+ List = 2,
+ Nil = 3,
+ Text = 1,
+ Undefined = 0,
}
public enum ImapResponseCondition : int {
- Bad = 2,
- Bye = 4,
- No = 1,
- Ok = 0,
- PreAuth = 3,
- Undefined = 5,
+ Bad = -2,
+ Bye = -3,
+ No = -1,
+ Ok = 1,
+ PreAuth = 2,
+ Undefined = 0,
}
public sealed class ImapCommand {
- public ImapCommand(string commandString) {}
- public ImapCommand(string commandString, string tag, params ImapString[] arguments) {}
-
- public ImapString[] Arguments { get; }
- public string CommandString { get; }
+ 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 string Text { get; }
+ 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 ImapCommandResult() {}
- public ImapCommandResultCode Code { get; }
public string Description { get; }
- public bool Failed { get; }
- public virtual IEnumerable<ImapResponse> ReceivedResponses { get; internal protected set; }
- public string ResponseText { get; }
- public string ResultText { get; }
- public bool Succeeded { 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 ImapServerDataResponse GetResponse(ImapServerDataResponseType type) {}
- public ImapStatusResponse GetResponseCode(ImapResponseCode code) {}
+ public ImapStatusResponse GetStatusResponseOfCode(ImapResponseCode code) {}
+ public bool IsFinalResponseCondition(ImapResponseCondition condition) {}
public override string ToString() {}
- public static explicit operator bool(ImapCommandResult r) {}
}
public sealed class ImapCommandSender : ImapSender {
public ImapCommandSender(LineOrientedBufferedStream stream) {}
- public bool CommandContinuing { get; }
+ public bool IsCommandContinuing { get; }
public void Send(ImapCommand command) {}
+ public void SendRemainder() {}
}
- public sealed class ImapConnection : ImapConnectionBase {
- public interface ICommandContinuationContext {
+ public sealed class ImapConnection : ConnectionBase {
+ public class CommandContinuationContext {
}
- public ImapConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStreamCallback) {}
+ public ImapConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStream) {}
- public DateTime LastSentTime { get; }
- public bool ReceiveResponseAsUTF8 { get; set; }
+ public bool IsIdling { get; }
public static TraceSource TraceSource { get; }
- public ImapCommand CreateCommand(string command, params ImapString[] arguments) {}
- public ImapCommand CreateContinuingCommand(params ImapString[] arguments) {}
- protected override ImapReceiver CreateReceiver(LineOrientedBufferedStream stream) {}
- protected override ImapSender CreateSender(LineOrientedBufferedStream stream) {}
- public ImapConnection.ICommandContinuationContext SendCommand(ImapCommand command) {}
- public ImapConnection.ICommandContinuationContext SendCommand(ImapConnection.ICommandContinuationContext context) {}
- public ImapResponse TryReceiveResponse() {}
- }
-
- public abstract class ImapConnectionBase : ConnectionBase {
- protected ImapConnectionBase(TraceSource traceSource) {}
-
- public bool IsIdling { get; protected set; }
- protected ImapReceiver Receiver { get; }
- protected ImapSender Sender { get; }
-
- protected override void Connect(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStreamCallback) {}
protected override LineOrientedBufferedStream CreateBufferedStream(Stream stream) {}
protected override Exception CreateConnectException(string message, Exception innerException) {}
- protected abstract ImapReceiver CreateReceiver(LineOrientedBufferedStream stream);
- protected abstract ImapSender CreateSender(LineOrientedBufferedStream stream);
protected override Exception CreateUpgradeStreamException(string message, Exception innerException) {}
+ public ImapConnection.CommandContinuationContext SendCommand(ImapCommand command) {}
+ public ImapConnection.CommandContinuationContext SendCommand(ImapConnection.CommandContinuationContext context) {}
+ public ImapResponse TryReceiveResponse() {}
}
[Serializable]
public abstract class ImapData : ISerializable {
- protected ImapData() {}
-
public abstract ImapDataFormat Format { get; }
- public virtual ImapData[] List { get; }
+ public virtual IReadOnlyList<ImapData> List { get; }
- public virtual void CopyText(byte[] buffer, int offset, int count) {}
- public static ImapData CreateListData(ImapData[] list) {}
- public static ImapData CreateNilData() {}
- public static ImapData CreateTextData(ByteString text) {}
- public static ImapData CreateTextData(Stream textStream) {}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
- public virtual int GetText(ref byte[] buffer) {}
- public virtual byte[] GetTextAsByteArray() {}
public virtual ByteString GetTextAsByteString() {}
- public virtual ulong GetTextAsNumber() {}
- public virtual Stream GetTextAsStream() {}
public virtual string GetTextAsString() {}
public virtual long GetTextLength() {}
+ public virtual void ReadText(Action<Stream> read) {}
}
public static class ImapDataParser {
- public static bool IsTextEqualsTo(ImapData data, string text) {}
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 ImapCapabilitySet ToCapability(ImapData[] list) {}
public static ImapCollationAlgorithm ToCompOrderQuoted(ImapData compOrderQuoted) {}
public static ImapCollationAlgorithm ToCompSelQuoted(ImapData compSelQuoted) {}
public static DateTimeOffset ToDateTime(ImapData dateTime) {}
- public static IReadOnlyList<string> ToEntryList(ImapData[] entryList) {}
+ public static IReadOnlyList<string> ToEntryList(IReadOnlyList<ImapData> entryList) {}
public static IReadOnlyList<ImapMetadata> ToEntryValues(ImapData entryValues) {}
public static ImapEnvelope ToEnvelope(ImapData envelope) {}
- public static long ToFetchMessageData<TMessageAttribute>(IImapMessageAttributeCollection<TMessageAttribute> messages, ImapData nzNumber, ImapData msgAtt) where TMessageAttribute : ImapMessageAttributeBase {}
- public static void ToFetchMessageData<TMessageAttribute>(ref TMessageAttribute message, ImapData nzNumber, ImapData msgAtt) where TMessageAttribute : ImapMessageAttributeBase {}
- public static IImapMessageFlagSet ToFlagFetch(ImapData[] flags) {}
- public static IImapMessageFlagSet ToFlagList(ImapData flagList) {}
- public static IImapMessageFlagSet ToFlagPerm(ImapData[] flags) {}
- public static IImapMessageFlagSet ToFlags(ImapData[] flags) {}
+ 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(ImapData[] mailboxList) {}
+ public static ImapListedMailbox ToMailboxList(IReadOnlyList<ImapData> mailboxList) {}
public static IReadOnlyDictionary<string, ImapData> ToMboxListExtended(ImapData mboxListExtended) {}
- public static IImapMailboxFlagSet ToMbxListFlags(ImapData[] list) {}
+ public static IReadOnlyStringSet<ImapMailboxFlag> ToMbxListFlags(IReadOnlyList<ImapData> list) {}
public static ulong ToModSequenceValue(ImapData modSequenceValue) {}
public static ulong ToModSequenceValzer(ImapData modSequenceValzer) {}
- public static bool ToMsgAtt(ImapMessageAttributeBase message, ImapData msgAtt) {}
+ 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 string ToSearchCorrelator(ImapData searchCorrelator) {}
- public static ImapMatchedSequenceSet ToSearchReturnData(ImapData[] searchReturnData, string tag, bool uid, int startIndex) {}
+ 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(ImapData[] statusAttList) {}
+ public static ImapStatusAttributes ToStatusAttList(IReadOnlyList<ImapData> statusAttList) {}
public static string ToString(ImapData @string) {}
public static IReadOnlyList<ImapThreadList> ToThreadList(bool uid, ImapData threadList) {}
- public static ImapThreadList ToThreadList(bool uid, ImapData[] threadLists) {}
- public static ImapThreadList ToThreadMembers(bool uid, ImapData[] threadMembers) {}
- public static IReadOnlyList<ImapThreadList> ToThreadNested(bool uid, ImapData[] list) {}
+ 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 class ImapFormatException : FormatException {
+ public abstract class ImapFormatException : FormatException {
+ protected ImapFormatException() {}
protected ImapFormatException(SerializationInfo info, StreamingContext context) {}
- public ImapFormatException() {}
- public ImapFormatException(string message) {}
- public ImapFormatException(string message, Exception innerException) {}
+ 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 interface IParsingContext {
+ protected sealed class ParsingContext {
}
protected ImapReceiver(LineOrientedBufferedStream stream) {}
- protected ImapData[] ParseData(ByteString line, int offset, ref ImapReceiver.IParsingContext context) {}
- protected ImapData[] ParseDataNonTerminatedText(ByteString text, int offset) {}
+ 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 {
- internal protected ImapResponse() {}
}
public sealed class ImapResponseReceiver : ImapReceiver {
public ImapResponseReceiver(LineOrientedBufferedStream stream) {}
+ public bool IsResponseContinuing { get; }
public bool ReceiveResponseAsUTF8 { get; set; }
- public bool ResponseContinuing { get; }
public ImapResponse ReceiveResponse() {}
}
[Serializable]
public sealed class ImapResponseText {
- public ImapData[] Arguments { get; }
+ 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 string[] FromBadCharset(ImapResponseText respText) {}
- public static ImapCapabilitySet FromCapability(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 IImapMessageFlagSet FromPermanentFlags(ImapResponseText respText) {}
- public static Uri[] FromReferral(ImapResponseText respText) {}
+ 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) {}
- protected LineOrientedBufferedStream Stream { get; }
- internal protected int UnsentFragments { get; }
+ internal protected int UnsentFragmentCount { get; }
protected void ClearUnsent() {}
protected void Enqueue(bool terminateByCrLf, IEnumerable<ImapString> args) {}
- public void Send() {}
+ protected void Send() {}
}
[Serializable]
- public sealed class ImapServerDataResponse : ImapResponse {
- public ImapData[] Data { get; }
+ 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 ImapCapabilitySet FromCapability(ImapServerDataResponse data) {}
- public static ImapCollationAlgorithm FromComparator(ImapServerDataResponse data, out ImapCollationAlgorithm[] matchingComparators) {}
+ 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 ImapCapabilitySet FromEnabled(ImapServerDataResponse data) {}
+ public static IReadOnlyStringSet<ImapCapability> FromEnabled(ImapServerDataResponse data) {}
public static long FromExists(ImapServerDataResponse data) {}
public static long FromExpunge(ImapServerDataResponse data) {}
- public static TMessageAttribute FromFetch<TMessageAttribute>(ImapServerDataResponse data) where TMessageAttribute : ImapMessageAttributeBase {}
- public static long FromFetch<TMessageAttribute>(IImapMessageAttributeCollection<TMessageAttribute> messages, ImapServerDataResponse data) where TMessageAttribute : ImapMessageAttributeBase {}
- public static IImapMessageFlagSet FromFlags(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 string[] FromLanguage(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 string[] quotaRootNames) {}
+ 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 ImapThreadList FromThread(ImapServerDataResponse data, bool uidSet) {}
}
[Serializable]
public abstract class ImapStatusResponse : ImapResponse {
- internal protected ImapStatusResponse(ImapResponseCondition condition, ImapResponseText responseText) {}
-
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 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 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 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 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 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 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() {}
}
}