--- product: Chilkat product_version: 11.7.0 language: ckruby language_label: Ruby class: Imap class_name: CkImap license: bundle deprecated: false reference_html: https://www.chilkatsoft.com/refdoc/rubyCkImapRef.html --- # Chilkat Imap — Ruby — v11.7.0 > Chilkat 11.7.0 · language=ckruby · class=Imap (CkImap) > Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0//classes/Imap.md`. > Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/guide.md`. ## Purpose **Access, search, download, organize, and monitor email on IMAP servers.** `Chilkat.Imap` is a full-featured IMAP client class for applications that need reliable server-side email access and mailbox management. It supports secure connections, authentication, mailbox selection, message searching, downloading email and attachments, flag management, moving and copying messages, appending MIME, IDLE-based change monitoring, and detailed diagnostics for troubleshooting server behavior. **Secure IMAP connections** Connect with SSL/TLS, STARTTLS, OAuth2, password authentication, proxy settings, timeouts, and connection diagnostics. **Mailbox selection and listing** List mailboxes, select folders, inspect mailbox state, and work with server-side folders such as Inbox, Sent, Archive, or custom folders. **Search and fetch messages** Search by IMAP criteria, work with UIDs or sequence numbers, download full messages, headers, MIME, body text, or selected message parts. **Message management** Set and clear flags, mark messages read or unread, copy or move messages, delete messages, expunge mailboxes, and append MIME to folders. **Attachments and MIME** Retrieve email as Chilkat `Email` objects, process MIME content, and save or inspect attachments as needed. **IDLE and diagnostics** Monitor mailbox changes with IMAP IDLE and use detailed logging, response text, and `LastErrorText` to troubleshoot servers. **Common pattern:** Connect securely, authenticate, select a mailbox, search or fetch messages using UIDs when possible, perform message or folder operations, then disconnect cleanly. Use detailed diagnostics when working with provider- specific IMAP behavior. For an extended overview, see [Imap Class Overview](https://www.chilkatsoft.com/imap_class_overview.asp). ## Object creation, unlocking and error handling **Object Creation** ```ruby obj = Chilkat::CkImap.new() ``` Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Ruby. How failure is reported depends on the method's return type and is stated in the note under each method below. In every case the diagnostic text is in the `LastErrorText` property of the object whose method was called. ## Members common to every Chilkat class Documented once per language in `common-members.md`; listed here so this page is self-contained. | Property | Signature | Access | Meaning | |---|---|---|---| | `DebugLogFilePath` | `# strVal is a string # ckStr is a CkString imap.get_DebugLogFilePath(ckStr); strVal = imap.debugLogFilePath(); imap.put_DebugLogFilePath(strVal);` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. | | `LastErrorHtml` | `# strVal is a string # ckStr is a CkString imap.get_LastErrorHtml(ckStr); strVal = imap.lastErrorHtml();` | read-only | Provides HTML-formatted information about the last called method or property. | | `LastErrorText` | `# strVal is a string # ckStr is a CkString imap.get_LastErrorText(ckStr); strVal = imap.lastErrorText();` | read-only | Provides plain text information about the last called method or property. | | `LastErrorXml` | `# strVal is a string # ckStr is a CkString imap.get_LastErrorXml(ckStr); strVal = imap.lastErrorXml();` | read-only | Provides XML-formatted information about the last called method or property. | | `LastMethodSuccess` | `# boolVal is a boolean boolVal = imap.get_LastMethodSuccess(); imap.put_LastMethodSuccess(boolVal);` | read/write | Indicates the success or failure of the most recent method call: `true` means success, `false` means failure. | | `Utf8` | `# boolVal is a boolean boolVal = imap.get_Utf8(); imap.put_Utf8(boolVal);` | read/write | When set to `true`, all `string` arguments and return values are interpreted as UTF-8 strings. | | `VerboseLogging` | `# boolVal is a boolean boolVal = imap.get_VerboseLogging(); imap.put_VerboseLogging(boolVal);` | read/write | If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. | | `Version` | `# strVal is a string # ckStr is a CkString imap.get_Version(ckStr); strVal = imap.version();` | read-only | Version of the component/library, such as "10.1.0" | ## Member index | Member | Kind | Signature | |---|---|---| | `AbortCurrent` | property, read/write | `# boolVal is a boolean boolVal = imap.get_AbortCurrent(); imap.put_AbortCurrent(boolVal);` | | `AppendSeen` | property, read/write | `# boolVal is a boolean boolVal = imap.get_AppendSeen(); imap.put_AppendSeen(boolVal);` | | `AppendUid` | property, read-only | `# intVal is an integer intVal = imap.get_AppendUid();` | | `AuthMethod` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_AuthMethod(ckStr); strVal = imap.authMethod(); imap.put_AuthMethod(strVal);` | | `AuthzId` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_AuthzId(ckStr); strVal = imap.authzId(); imap.put_AuthzId(strVal);` | | `AutoDownloadAttachments` | property, read/write | `# boolVal is a boolean boolVal = imap.get_AutoDownloadAttachments(); imap.put_AutoDownloadAttachments(boolVal);` | | `AutoFix` | property, read/write | `# boolVal is a boolean boolVal = imap.get_AutoFix(); imap.put_AutoFix(boolVal);` | | `ClientIpAddress` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_ClientIpAddress(ckStr); strVal = imap.clientIpAddress(); imap.put_ClientIpAddress(strVal);` | | `ConnectedToHost` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_ConnectedToHost(ckStr); strVal = imap.connectedToHost();` | | `ConnectTimeout` | property, read/write | `# intVal is an integer intVal = imap.get_ConnectTimeout(); imap.put_ConnectTimeout(intVal);` | | `Domain` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_Domain(ckStr); strVal = imap.domain(); imap.put_Domain(strVal);` | | `EnableSecrets` | property, read/write | `# boolVal is a boolean boolVal = imap.get_EnableSecrets(); imap.put_EnableSecrets(boolVal);` | | `HighestModSeq` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_HighestModSeq(ckStr); strVal = imap.highestModSeq();` | | `HttpProxyAuthMethod` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_HttpProxyAuthMethod(ckStr); strVal = imap.httpProxyAuthMethod(); imap.put_HttpProxyAuthMethod(strVal);` | | `HttpProxyDomain` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_HttpProxyDomain(ckStr); strVal = imap.httpProxyDomain(); imap.put_HttpProxyDomain(strVal);` | | `HttpProxyHostname` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_HttpProxyHostname(ckStr); strVal = imap.httpProxyHostname(); imap.put_HttpProxyHostname(strVal);` | | `HttpProxyPassword` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_HttpProxyPassword(ckStr); strVal = imap.httpProxyPassword(); imap.put_HttpProxyPassword(strVal);` | | `HttpProxyPort` | property, read/write | `# intVal is an integer intVal = imap.get_HttpProxyPort(); imap.put_HttpProxyPort(intVal);` | | `HttpProxyUsername` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_HttpProxyUsername(ckStr); strVal = imap.httpProxyUsername(); imap.put_HttpProxyUsername(strVal);` | | `KeepSessionLog` | property, read/write | `# boolVal is a boolean boolVal = imap.get_KeepSessionLog(); imap.put_KeepSessionLog(boolVal);` | | `LastAppendedMime` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_LastAppendedMime(ckStr); strVal = imap.lastAppendedMime();` | | `LastCommand` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_LastCommand(ckStr); strVal = imap.lastCommand();` | | `LastIntermediateResponse` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_LastIntermediateResponse(ckStr); strVal = imap.lastIntermediateResponse();` | | `LastResponse` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_LastResponse(ckStr); strVal = imap.lastResponse();` | | `LastResponseCode` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_LastResponseCode(ckStr); strVal = imap.lastResponseCode();` | | `LoggedInUser` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_LoggedInUser(ckStr); strVal = imap.loggedInUser();` | | `NumMessages` | property, read-only | `# intVal is an integer intVal = imap.get_NumMessages();` | | `PeekMode` | property, read/write | `# boolVal is a boolean boolVal = imap.get_PeekMode(); imap.put_PeekMode(boolVal);` | | `Port` | property, read/write | `# intVal is an integer intVal = imap.get_Port(); imap.put_Port(intVal);` | | `PreferIpv6` | property, read/write | `# boolVal is a boolean boolVal = imap.get_PreferIpv6(); imap.put_PreferIpv6(boolVal);` | | `ReadTimeout` | property, read/write | `# intVal is an integer intVal = imap.get_ReadTimeout(); imap.put_ReadTimeout(intVal);` | | `RequireSslCertVerify` | property, read/write | `# boolVal is a boolean boolVal = imap.get_RequireSslCertVerify(); imap.put_RequireSslCertVerify(boolVal);` | | `SearchCharset` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SearchCharset(ckStr); strVal = imap.searchCharset(); imap.put_SearchCharset(strVal);` | | `SelectedMailbox` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_SelectedMailbox(ckStr); strVal = imap.selectedMailbox();` | | `SendBufferSize` | property, read/write | `# intVal is an integer intVal = imap.get_SendBufferSize(); imap.put_SendBufferSize(intVal);` | | `SeparatorChar` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SeparatorChar(ckStr); strVal = imap.separatorChar(); imap.put_SeparatorChar(strVal);` | | `SessionLog` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_SessionLog(ckStr); strVal = imap.sessionLog();` | | `SocksHostname` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SocksHostname(ckStr); strVal = imap.socksHostname(); imap.put_SocksHostname(strVal);` | | `SocksPassword` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SocksPassword(ckStr); strVal = imap.socksPassword(); imap.put_SocksPassword(strVal);` | | `SocksPort` | property, read/write | `# intVal is an integer intVal = imap.get_SocksPort(); imap.put_SocksPort(intVal);` | | `SocksUsername` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SocksUsername(ckStr); strVal = imap.socksUsername(); imap.put_SocksUsername(strVal);` | | `SocksVersion` | property, read/write | `# intVal is an integer intVal = imap.get_SocksVersion(); imap.put_SocksVersion(intVal);` | | `SoRcvBuf` | property, read/write | `# intVal is an integer intVal = imap.get_SoRcvBuf(); imap.put_SoRcvBuf(intVal);` | | `SortCriteria` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SortCriteria(ckStr); strVal = imap.sortCriteria(); imap.put_SortCriteria(strVal);` | | `SoSndBuf` | property, read/write | `# intVal is an integer intVal = imap.get_SoSndBuf(); imap.put_SoSndBuf(intVal);` | | `Ssl` | property, read/write | `# boolVal is a boolean boolVal = imap.get_Ssl(); imap.put_Ssl(boolVal);` | | `SslAllowedCiphers` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SslAllowedCiphers(ckStr); strVal = imap.sslAllowedCiphers(); imap.put_SslAllowedCiphers(strVal);` | | `SslProtocol` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_SslProtocol(ckStr); strVal = imap.sslProtocol(); imap.put_SslProtocol(strVal);` | | `SslServerCertVerified` | property, read-only | `# boolVal is a boolean boolVal = imap.get_SslServerCertVerified();` | | `StartTls` | property, read/write | `# boolVal is a boolean boolVal = imap.get_StartTls(); imap.put_StartTls(boolVal);` | | `TlsCipherSuite` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_TlsCipherSuite(ckStr); strVal = imap.tlsCipherSuite();` | | `TlsPinSet` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_TlsPinSet(ckStr); strVal = imap.tlsPinSet(); imap.put_TlsPinSet(strVal);` | | `TlsVersion` | property, read-only | `# strVal is a string # ckStr is a CkString imap.get_TlsVersion(ckStr); strVal = imap.tlsVersion();` | | `UidNext` | property, read-only | `# intVal is a unsigned long intVal = imap.get_UidNext();` | | `UidValidity` | property, read-only | `# intVal is a unsigned long intVal = imap.get_UidValidity();` | | `UncommonOptions` | property, read/write | `# strVal is a string # ckStr is a CkString imap.get_UncommonOptions(ckStr); strVal = imap.uncommonOptions(); imap.put_UncommonOptions(strVal);` | | `AddPfxSourceBd` | method | `# bd is a CkBinData # password is a string status = imap.AddPfxSourceBd(bd, password);` | | `AddPfxSourceFile` | method | `# pfxFilePath is a string # pfxPassword is a string status = imap.AddPfxSourceFile(pfxFilePath, pfxPassword);` | | `AppendMail` | method | `# mailbox is a string # email is a CkEmail status = imap.AppendMail(mailbox, email);` | | `AppendMime` | method | `# mailbox is a string # mimeText is a string status = imap.AppendMime(mailbox, mimeText);` | | `AppendMimeWithDateStr` | method | `# mailbox is a string # mimeText is a string # internalDateStr is a string status = imap.AppendMimeWithDateStr(mailbox, mimeText, internalDateStr);` | | `AppendMimeWithFlags` | method | `# mailbox is a string # mimeText is a string # seen is a boolean # flagged is a boolean # answered is a boolean # draft is a boolean status = imap.AppendMimeWithFlags(mailbox, mimeText, seen, flagged, answered, draft);` | | `AppendMimeWithFlagsSb` | method | `# mailbox is a string # sbMime is a CkStringBuilder # seen is a boolean # flagged is a boolean # answered is a boolean # draft is a boolean status = imap.AppendMimeWithFlagsSb(mailbox, sbMime, seen, flagged, answered, draft);` | | `Capability` | method | `# outStr is a CkString (output) status = imap.Capability(outStr); retStr = imap.capability();` | | `CheckConnection` | method | `retBool = imap.CheckConnection();` | | `ClearSessionLog` | method | `imap.ClearSessionLog();` | | `CloseMailbox` | method | `# mailbox is a string status = imap.CloseMailbox(mailbox);` | | `Connect` | method | `# domainName is a string status = imap.Connect(domainName);` | | `Copy` | method | `# msgId is an integer # bUid is a boolean # copyToMailbox is a string status = imap.Copy(msgId, bUid, copyToMailbox);` | | `CopyMultiple` | method | `# messageSet is a CkMessageSet # copyToMailbox is a string status = imap.CopyMultiple(messageSet, copyToMailbox);` | | `CopySequence` | method | `# startSeqNum is an integer # count is an integer # copyToMailbox is a string status = imap.CopySequence(startSeqNum, count, copyToMailbox);` | | `CreateMailbox` | method | `# mailbox is a string status = imap.CreateMailbox(mailbox);` | | `DeleteMailbox` | method | `# mailbox is a string status = imap.DeleteMailbox(mailbox);` | | `Disconnect` | method | `status = imap.Disconnect();` | | `ExamineMailbox` | method | `# mailbox is a string status = imap.ExamineMailbox(mailbox);` | | `Expunge` | method | `status = imap.Expunge();` | | `ExpungeAndClose` | method | `status = imap.ExpungeAndClose();` | | `FetchAttachment` | method | `# emailObject is a CkEmail # attachmentIndex is an integer # saveToPath is a string status = imap.FetchAttachment(emailObject, attachmentIndex, saveToPath);` | | `FetchAttachmentBd` | method | `# email is a CkEmail # attachmentIndex is an integer # binData is a CkBinData status = imap.FetchAttachmentBd(email, attachmentIndex, binData);` | | `FetchAttachmentSb` | method | `# email is a CkEmail # attachmentIndex is an integer # charset is a string # sb is a CkStringBuilder status = imap.FetchAttachmentSb(email, attachmentIndex, charset, sb);` | | `FetchAttachmentString` | method | `# emailObject is a CkEmail # attachmentIndex is an integer # charset is a string # outStr is a CkString (output) status = imap.FetchAttachmentString(emailObject, attachmentIndex, charset, outStr); retStr = imap.fetchAttachmentString(emailObject, attachmentIndex, charset);` | | `FetchChunk2` | method | `# seqnum is an integer # count is an integer # failedSet is a CkMessageSet # fetchedSet is a CkMessageSet # bundle is a CkEmailBundle status = imap.FetchChunk2(seqnum, count, failedSet, fetchedSet, bundle);` | | `FetchEmail` | method | `# headerOnly is a boolean # msgId is an integer # bUid is a boolean # email is a CkEmail status = imap.FetchEmail(headerOnly, msgId, bUid, email);` | | `FetchFlags` | method | `# msgId is an integer # bUid is a boolean # outStrFlags is a CkString (output) status = imap.FetchFlags(msgId, bUid, outStr); retStr = imap.fetchFlags(msgId, bUid);` | | `FetchMsgSet` | method | `# headersOnly is a boolean # msgSet is a CkMessageSet # bundle is a CkEmailBundle status = imap.FetchMsgSet(headersOnly, msgSet, bundle);` | | `FetchRange` | method | `# headersOnly is a boolean # seqnum is an integer # count is an integer # bundle is a CkEmailBundle status = imap.FetchRange(headersOnly, seqnum, count, bundle);` | | `FetchSingleAsMime` | method | `# msgId is an integer # bUid is a boolean # outStrMime is a CkString (output) status = imap.FetchSingleAsMime(msgId, bUid, outStr); retStr = imap.fetchSingleAsMime(msgId, bUid);` | | `FetchSingleAsMimeSb` | method | `# msgId is an integer # bUid is a boolean # sbMime is a CkStringBuilder status = imap.FetchSingleAsMimeSb(msgId, bUid, sbMime);` | | `FetchSingleBd` | method | `# msgId is an integer # bUid is a boolean # mimeData is a CkBinData status = imap.FetchSingleBd(msgId, bUid, mimeData);` | | `FetchSingleHeaderAsMime` | method | `# msgId is an integer # bUID is a boolean # outStr is a CkString (output) status = imap.FetchSingleHeaderAsMime(msgId, bUID, outStr); retStr = imap.fetchSingleHeaderAsMime(msgId, bUID);` | | `GetMailAttachFilename` | method | `# email is a CkEmail # attachIndex is an integer # outStrFilename is a CkString (output) status = imap.GetMailAttachFilename(email, attachIndex, outStr); retStr = imap.getMailAttachFilename(email, attachIndex);` | | `GetMailAttachSize` | method | `# email is a CkEmail # attachIndex is an integer retInt = imap.GetMailAttachSize(email, attachIndex);` | | `GetMailboxStatus` | method | `# mailbox is a string # outStr is a CkString (output) status = imap.GetMailboxStatus(mailbox, outStr); retStr = imap.getMailboxStatus(mailbox);` | | `GetMailFlag` | method | `# email is a CkEmail # flagName is a string retInt = imap.GetMailFlag(email, flagName);` | | `GetMailNumAttach` | method | `# email is a CkEmail retInt = imap.GetMailNumAttach(email);` | | `GetMailSize` | method | `# email is a CkEmail retInt = imap.GetMailSize(email);` | | `GetQuota` | method | `# quotaRoot is a string # outStr is a CkString (output) status = imap.GetQuota(quotaRoot, outStr); retStr = imap.getQuota(quotaRoot);` | | `GetQuotaRoot` | method | `# mailboxName is a string # outStr is a CkString (output) status = imap.GetQuotaRoot(mailboxName, outStr); retStr = imap.getQuotaRoot(mailboxName);` | | `GetServerCert` | method | `# cert is a CkCert status = imap.GetServerCert(cert);` | | `HasCapability` | method | `# name is a string # capabilityResponse is a string retBool = imap.HasCapability(name, capabilityResponse);` | | `IdleCheck` | method | `# timeoutMs is an integer # outStr is a CkString (output) status = imap.IdleCheck(timeoutMs, outStr); retStr = imap.idleCheck(timeoutMs);` | | `IdleDone` | method | `status = imap.IdleDone();` | | `IdleStart` | method | `status = imap.IdleStart();` | | `IsConnected` | method | `retBool = imap.IsConnected();` | | `IsLoggedIn` | method | `retBool = imap.IsLoggedIn();` | | `LoadTaskCaller` | method | `# task is a CkTask status = imap.LoadTaskCaller(task);` | | `Login` | method | `# loginName is a string # password is a string status = imap.Login(loginName, password);` | | `LoginSecure` | method | `# loginName is a CkSecureString # password is a CkSecureString status = imap.LoginSecure(loginName, password);` | | `Logout` | method | `status = imap.Logout();` | | `MbxList` | method | `# subscribed is a boolean # reference is a string # mbxPattern is a string # mboxes is a CkMailboxes status = imap.MbxList(subscribed, reference, mbxPattern, mboxes);` | | `MoveMessages` | method | `# messageSet is a CkMessageSet # destFolder is a string status = imap.MoveMessages(messageSet, destFolder);` | | `Noop` | method | `status = imap.Noop();` | | `QueryMbx` | method | `# criteria is a string # bUid is a boolean # msgSet is a CkMessageSet status = imap.QueryMbx(criteria, bUid, msgSet);` | | `QueryThread` | method | `# threadAlg is a string # searchCriteria is a string # bUid is a boolean # json is a CkJsonObject status = imap.QueryThread(threadAlg, searchCriteria, bUid, json);` | | `RawCommandBd` | method | `# bdCmd is a CkBinData # bdResp is a CkBinData status = imap.RawCommandBd(bdCmd, bdResp);` | | `RefetchMailFlags` | method | `# email is a CkEmail status = imap.RefetchMailFlags(email);` | | `RenameMailbox` | method | `# fromMailbox is a string # toMailbox is a string status = imap.RenameMailbox(fromMailbox, toMailbox);` | | `SelectMailbox` | method | `# mailbox is a string status = imap.SelectMailbox(mailbox);` | | `SendRawCommand` | method | `# cmd is a string # outRawResponse is a CkString (output) status = imap.SendRawCommand(cmd, outStr); retStr = imap.sendRawCommand(cmd);` | | `SetDecryptCert` | method | `# cert is a CkCert status = imap.SetDecryptCert(cert);` | | `SetDecryptCert2` | method | `# cert is a CkCert # key is a CkPrivateKey status = imap.SetDecryptCert2(cert, key);` | | `SetFlag` | method | `# msgId is an integer # bUid is a boolean # flagName is a string # value is an integer status = imap.SetFlag(msgId, bUid, flagName, value);` | | `SetFlags` | method | `# messageSet is a CkMessageSet # flagName is a string # value is an integer status = imap.SetFlags(messageSet, flagName, value);` | | `SetMailFlag` | method | `# email is a CkEmail # flagName is a string # value is an integer status = imap.SetMailFlag(email, flagName, value);` | | `SetQuota` | method | `# quotaRoot is a string # resource is a string # quota is an integer status = imap.SetQuota(quotaRoot, resource, quota);` | | `SetSslClientCert` | method | `# cert is a CkCert status = imap.SetSslClientCert(cert);` | | `SetSslClientCertPem` | method | `# pemDataOrFilename is a string # pemPassword is a string status = imap.SetSslClientCertPem(pemDataOrFilename, pemPassword);` | | `SetSslClientCertPfx` | method | `# pfxFilename is a string # pfxPassword is a string status = imap.SetSslClientCertPfx(pfxFilename, pfxPassword);` | | `SshAuthenticatePk` | method | `# sshLogin is a string # privateKey is a CkSshKey status = imap.SshAuthenticatePk(sshLogin, privateKey);` | | `SshAuthenticatePw` | method | `# sshLogin is a string # sshPassword is a string status = imap.SshAuthenticatePw(sshLogin, sshPassword);` | | `SshCloseTunnel` | method | `status = imap.SshCloseTunnel();` | | `SshOpenTunnel` | method | `# sshHostname is a string # sshPort is an integer status = imap.SshOpenTunnel(sshHostname, sshPort);` | | `StoreFlags` | method | `# msgId is an integer # bUid is a boolean # flagNames is a string # value is an integer status = imap.StoreFlags(msgId, bUid, flagNames, value);` | | `Subscribe` | method | `# mailbox is a string status = imap.Subscribe(mailbox);` | | `Unsubscribe` | method | `# mailbox is a string status = imap.Unsubscribe(mailbox);` | | `UseCertVault` | method | `# vault is a CkXmlCertVault status = imap.UseCertVault(vault);` | | `UseSsh` | method | `# ssh is a CkSsh status = imap.UseSsh(ssh);` | | `UseSshTunnel` | method | `# tunnel is a CkSocket status = imap.UseSshTunnel(tunnel);` | Deprecated members are listed at the end of this file with their replacements; do not use them in new code. ## Properties ### Imap.AbortCurrent `Chilkat 11.7.0 · ckruby · Imap · AbortCurrent · property · read/write · since 9.5.0.58` ```ruby # boolVal is a boolean boolVal = imap.get_AbortCurrent(); imap.put_AbortCurrent(boolVal); ``` Controls cancellation of the method currently running on this `Imap` object. - Set this property to `true` to request that a long-running network operation abort. - Short methods that do not perform lengthy processing or network communication are generally unaffected. - Both synchronous and asynchronous calls can be aborted. A synchronous call may be canceled by setting this property from another thread. The property is automatically reset to `false` when the abort is processed. If no method is running, it is reset when the next method begins. Canceling an operation can leave the connection in an uncertain state. Close the connection, reconnect, authenticate again, and reselect the mailbox before continuing. Output objects may contain partial results, and a server-side operation may already have been partially applied before cancellation. ### Imap.AppendSeen `Chilkat 11.7.0 · ckruby · Imap · AppendSeen · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_AppendSeen(); imap.put_AppendSeen(boolVal); ``` Controls the initial `\Seen` flag for these methods: - `AppendMail` - `AppendMime` - `AppendMimeWithDateStr` - `true` (the default): the appended message is marked as seen. - `false`: the appended message is initially unseen. The flag-specific append methods use their explicit arguments and do not use this property. ### Imap.AppendUid `Chilkat 11.7.0 · ckruby · Imap · AppendUid · property · read-only` ```ruby # intVal is an integer intVal = imap.get_AppendUid(); ``` Contains the UID assigned by the server to the message most recently appended successfully. The default is `0`. After any successful append, this property is set to the UID reported by the server, or to `0` if the server succeeds but does not report an appended UID. A failed append leaves the previous value unchanged. ### Imap.AuthMethod `Chilkat 11.7.0 · ckruby · Imap · AuthMethod · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_AuthMethod(ckStr); strVal = imap.authMethod(); imap.put_AuthMethod(strVal); ``` Selects the IMAP authentication mechanism. Matching is case-insensitive, but spelling matters. | Value | Purpose | | --- | --- | | `LOGIN` | Username and password authentication. | | `PLAIN` | SASL PLAIN authentication. `AuthzId` may also be used. | | `CRAM-MD5` | Challenge-response authentication when supported by the server. | | `NTLM` | Windows Integrated Authentication. | | `XOAUTH2` | OAuth 2.0 access-token authentication. | The default is `LOGIN`, and an empty or unrecognized value also uses the LOGIN method. If the selected mechanism fails or is not supported by the server, Chilkat does not fall back to another authentication method. If NTLM authentication fails because of an NTLM-version compatibility issue, set `Global.DefaultNtlmVersion` to `1` and retry. ### Imap.AuthzId `Chilkat 11.7.0 · ckruby · Imap · AuthzId · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_AuthzId(ckStr); strVal = imap.authzId(); imap.put_AuthzId(strVal); ``` Specifies the optional authorization identity used with the `PLAIN` authentication mechanism. Leave this property empty unless the IMAP server requires an authorization identity that differs from the login identity supplied to `Login`. ### Imap.AutoDownloadAttachments `Chilkat 11.7.0 · ckruby · Imap · AutoDownloadAttachments · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_AutoDownloadAttachments(); imap.put_AutoDownloadAttachments(boolVal); ``` Controls whether methods that download a complete email also download ordinary attachment bodies. The default is `true`. - `true`: complete-email fetches include attachment bodies. - `false`: complete-email fetches omit ordinary attachment bodies, whether the result is returned as an `Email` object or as MIME. Header-only methods never download attachment bodies. They add `ckx-imap-*` metadata describing the attachments, which can be read with `GetMailNumAttach`, `GetMailAttachFilename`, and `GetMailAttachSize`. In this state, the `Email` object's ordinary attachment count can still be `0`. Related MIME parts used by an HTML body are not treated as ordinary attachments. Signed or encrypted messages are always downloaded in full because their complete MIME is required for verification or decryption. See also: - [Fetching IMAP Attachments](http://www.cknotes.com/?p=393) - [Getting Attachment Information](http://www.cknotes.com/?p=434) ### Imap.AutoFix `Chilkat 11.7.0 · ckruby · Imap · AutoFix · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_AutoFix(); imap.put_AutoFix(boolVal); ``` When `true` (the default), changes the public `Ssl` and `StartTls` property values when `Connect` is called for a standard IMAP port: - Port `993`: sets `Ssl` to `true` and `StartTls` to `false` for implicit TLS. - Port `143`: sets `Ssl` to `false`. The existing `StartTls` value determines whether the connection is upgraded explicitly. For a nonstandard port, this property makes no changes. Set it to `false` when the application must preserve an unusual port and TLS combination exactly as configured. ### Imap.ClientIpAddress `Chilkat 11.7.0 · ckruby · Imap · ClientIpAddress · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_ClientIpAddress(ckStr); strVal = imap.clientIpAddress(); imap.put_ClientIpAddress(strVal); ``` Specifies the local IP address to bind when the computer has multiple network interfaces or addresses. Leave this property empty for the usual case. The operating system will select the default local interface. When set, use a numeric IP address such as `165.164.55.124`, not a hostname. See also: - [Important Bind to Adapter Notes for Windows](http://www.cknotes.com/?p=376) ### Imap.ConnectedToHost `Chilkat 11.7.0 · ckruby · Imap · ConnectedToHost · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_ConnectedToHost(ckStr); strVal = imap.connectedToHost(); ``` Contains the hostname or IP address of the IMAP server to which the object is currently connected. Returns an empty string when no connection is active. ### Imap.ConnectTimeout `Chilkat 11.7.0 · ckruby · Imap · ConnectTimeout · property · read/write` ```ruby # intVal is an integer intVal = imap.get_ConnectTimeout(); imap.put_ConnectTimeout(intVal); ``` The maximum number of seconds to wait while establishing the TCP connection to the IMAP server. The default is `30` seconds. This timeout applies to connection establishment, not to later reads from the server. ### Imap.Domain `Chilkat 11.7.0 · ckruby · Imap · Domain · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_Domain(ckStr); strVal = imap.domain(); imap.put_Domain(strVal); ``` Specifies the Windows domain used for NTLM authentication. This property is optional and may be left empty when the login name already identifies the domain or when NTLM is not used. ### Imap.EnableSecrets `Chilkat 11.7.0 · ckruby · Imap · EnableSecrets · property · read/write · since 11.5.0` ```ruby # boolVal is a boolean boolVal = imap.get_EnableSecrets(); imap.put_EnableSecrets(boolVal); ``` **Full documentation for this property (same in every language):** [More Detailed Information About EnableSecrets](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/secret_specification_strings.md) Enables automatic resolution of credential values from secure operating-system storage. The default is `false`. When `true`, supported password arguments and properties may contain a secret specification beginning with `!!` instead of a literal secret. Chilkat resolves the value from Windows Credential Manager or Apple Keychain. ``` !![appName|]service[|domain]|username ``` This applies to `HttpProxyPassword`, `SocksPassword`, the password supplied to `Login`, and the password supplied to `SshAuthenticatePw`. ### Imap.HighestModSeq `Chilkat 11.7.0 · ckruby · Imap · HighestModSeq · property · read-only · since 9.5.0.87` ```ruby # strVal is a string # ckStr is a CkString imap.get_HighestModSeq(ckStr); strVal = imap.highestModSeq(); ``` Contains the `HIGHESTMODSEQ` value of the currently selected mailbox as a decimal string. The value is `0` when no mailbox is selected or the server does not provide this information. A string is used because the value may exceed the integer range of some programming languages. ### Imap.HttpProxyAuthMethod `Chilkat 11.7.0 · ckruby · Imap · HttpProxyAuthMethod · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_HttpProxyAuthMethod(ckStr); strVal = imap.httpProxyAuthMethod(); imap.put_HttpProxyAuthMethod(strVal); ``` Specifies the authentication mechanism used by an HTTP proxy. Valid values are `Basic` and `NTLM`. This property is used only when `HttpProxyHostname` identifies an HTTP proxy that requires authentication. ### Imap.HttpProxyDomain `Chilkat 11.7.0 · ckruby · Imap · HttpProxyDomain · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_HttpProxyDomain(ckStr); strVal = imap.httpProxyDomain(); imap.put_HttpProxyDomain(strVal); ``` Specifies the optional Windows domain for HTTP-proxy NTLM authentication. It is ignored when the proxy does not use NTLM authentication. ### Imap.HttpProxyHostname `Chilkat 11.7.0 · ckruby · Imap · HttpProxyHostname · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_HttpProxyHostname(ckStr); strVal = imap.httpProxyHostname(); imap.put_HttpProxyHostname(strVal); ``` Specifies the hostname or numeric IPv4 address of an HTTP proxy through which the IMAP connection is established. Leave this property empty to connect directly or to use another configured transport such as SOCKS or SSH tunneling. ### Imap.HttpProxyPassword `Chilkat 11.7.0 · ckruby · Imap · HttpProxyPassword · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_HttpProxyPassword(ckStr); strVal = imap.httpProxyPassword(); imap.put_HttpProxyPassword(strVal); ``` Specifies the password used to authenticate with the configured HTTP proxy. It is used only when the proxy requires authentication. ### Imap.HttpProxyPort `Chilkat 11.7.0 · ckruby · Imap · HttpProxyPort · property · read/write` ```ruby # intVal is an integer intVal = imap.get_HttpProxyPort(); imap.put_HttpProxyPort(intVal); ``` Specifies the TCP port of the configured HTTP proxy. Common values include `8080` and `3128`, but the correct value is determined by the proxy server configuration. ### Imap.HttpProxyUsername `Chilkat 11.7.0 · ckruby · Imap · HttpProxyUsername · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_HttpProxyUsername(ckStr); strVal = imap.httpProxyUsername(); imap.put_HttpProxyUsername(strVal); ``` Specifies the username used to authenticate with the configured HTTP proxy. It is used only when the proxy requires authentication. ### Imap.KeepSessionLog `Chilkat 11.7.0 · ckruby · Imap · KeepSessionLog · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_KeepSessionLog(); imap.put_KeepSessionLog(boolVal); ``` Enables or disables the in-memory IMAP protocol log. The default is `false`. When enabled, `SessionLog` contains the raw commands sent to the server and the raw responses received. Use `ClearSessionLog` to reset it. ### Imap.LastAppendedMime `Chilkat 11.7.0 · ckruby · Imap · LastAppendedMime · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_LastAppendedMime(ckStr); strVal = imap.lastAppendedMime(); ``` Contains the MIME source sent by the most recent successful call to one of the following methods: - `AppendMail` - `AppendMime` - `AppendMimeWithDateStr` - `AppendMimeWithFlags` - `AppendMimeWithFlagsSb` A failed append leaves the previous value unchanged. Therefore, read this property only after confirming that the append method succeeded. ### Imap.LastCommand `Chilkat 11.7.0 · ckruby · Imap · LastCommand · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_LastCommand(ckStr); strVal = imap.lastCommand(); ``` Contains the most recent raw IMAP command sent to the server. This property is primarily intended for diagnostics when an IMAP operation fails or produces an unexpected response. ### Imap.LastIntermediateResponse `Chilkat 11.7.0 · ckruby · Imap · LastIntermediateResponse · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_LastIntermediateResponse(ckStr); strVal = imap.lastIntermediateResponse(); ``` Contains the most recent intermediate response received from the IMAP server while a command was in progress. Use it for protocol-level diagnostics when a command involves continuations or multiple response stages. ### Imap.LastResponse `Chilkat 11.7.0 · ckruby · Imap · LastResponse · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_LastResponse(ckStr); strVal = imap.lastResponse(); ``` Contains the raw response most recently received from the IMAP server. This property is cleared when Chilkat sends a new command. If a method fails during local argument validation or before a command is sent, the previous response can remain here. Also, a method can return failure even when the last tagged server response is `OK`, such as when a syntactically successful `FETCH` returns no matching message. Use the method return value or `LastMethodSuccess` as the authoritative success indicator. ### Imap.LastResponseCode `Chilkat 11.7.0 · ckruby · Imap · LastResponseCode · property · read-only · since 9.5.0.44` ```ruby # strVal is a string # ckStr is a CkString imap.get_LastResponseCode(ckStr); strVal = imap.lastResponseCode(); ``` Contains the optional IMAP response code from the most recent server response, such as `NONEXISTENT` or `AUTHENTICATIONFAILED`. Response-code strings vary by server. If a method fails before sending an IMAP command, this property can still contain the response code from an earlier command. Use the method return value or `LastMethodSuccess` to determine whether the current operation succeeded. ### Imap.LoggedInUser `Chilkat 11.7.0 · ckruby · Imap · LoggedInUser · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_LoggedInUser(ckStr); strVal = imap.loggedInUser(); ``` Contains the username of the authenticated IMAP session. Returns an empty string when the object is not logged in. ### Imap.NumMessages `Chilkat 11.7.0 · ckruby · Imap · NumMessages · property · read-only` ```ruby # intVal is an integer intVal = imap.get_NumMessages(); ``` Contains the number of messages reported when the current mailbox was selected. The value is updated by `SelectMailbox` and `ExamineMailbox`. Unsolicited `EXISTS` notifications returned by `IdleCheck` do not automatically update this property; use the notification value or reselect/query the mailbox when a refreshed count is needed. ### Imap.PeekMode `Chilkat 11.7.0 · ckruby · Imap · PeekMode · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_PeekMode(); imap.put_PeekMode(boolVal); ``` Controls whether fetching full message content marks the message as seen. - `false` (the default): fetching a full message or its raw MIME may set the `\Seen` flag. - `true`: full message data and raw MIME are fetched without setting `\Seen`, using IMAP peek semantics. Fetching headers only does not set `\Seen`, regardless of this property. ### Imap.Port `Chilkat 11.7.0 · ckruby · Imap · Port · property · read/write` ```ruby # intVal is an integer intVal = imap.get_Port(); imap.put_Port(intVal); ``` Specifies the IMAP server port. The default is `143`. - `993` is the standard port for implicit TLS and is normally used with `Ssl` set to `true`. - `143` is the standard port for ordinary IMAP and for explicit TLS requested with `StartTls`. When `AutoFix` is enabled, standard port values are used to adjust the effective TLS configuration when connecting. ### Imap.PreferIpv6 `Chilkat 11.7.0 · ckruby · Imap · PreferIpv6 · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_PreferIpv6(); imap.put_PreferIpv6(boolVal); ``` Controls address-family preference when a hostname resolves to both IPv4 and IPv6 addresses. - `false` (the default): prefer IPv4. - `true`: prefer IPv6. The other address family may still be used when the preferred one is unavailable. ### Imap.ReadTimeout `Chilkat 11.7.0 · ckruby · Imap · ReadTimeout · property · read/write` ```ruby # intVal is an integer intVal = imap.get_ReadTimeout(); imap.put_ReadTimeout(intVal); ``` The maximum number of seconds that an incoming IMAP response may stall with no additional bytes received. The default is `60` seconds. This is an inactivity timeout, not a limit on the total time allowed for a large response. ### Imap.RequireSslCertVerify `Chilkat 11.7.0 · ckruby · Imap · RequireSslCertVerify · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_RequireSslCertVerify(); imap.put_RequireSslCertVerify(boolVal); ``` Controls verification of the IMAP server's TLS certificate chain. - `false` (the default): a connection is not rejected solely because normal certificate-chain verification fails. - `true`: the connection fails when the certificate is expired, is not yet valid, its signature is invalid, or its chain cannot be verified to a trusted root. Certificate-chain verification is separate from hostname matching and public-key pinning. Hostname matching, when required, is enforced independently even when this property is `false`. `TlsPinSet` supplements rather than replaces normal certificate verification. The hostname used for the TLS connection is also used for Server Name Indication (SNI) and certificate hostname comparison. ### Imap.SearchCharset `Chilkat 11.7.0 · ckruby · Imap · SearchCharset · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_SearchCharset(ckStr); strVal = imap.searchCharset(); imap.put_SearchCharset(strVal); ``` Specifies the IMAP `CHARSET` used by `Search`, `QueryMbx`, and `QueryThread` when search criteria contain non-ASCII characters. The default is `UTF-8`. If the criteria contain only 7-bit ASCII characters, no `CHARSET` is needed and this property has no effect. The value `AUTO` enables the legacy behavior of selecting a charset by examining the criteria text. Most applications should leave this property unchanged unless a particular server rejects non-English search text. ### Imap.SelectedMailbox `Chilkat 11.7.0 · ckruby · Imap · SelectedMailbox · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_SelectedMailbox(ckStr); strVal = imap.selectedMailbox(); ``` Contains the name of the currently selected or examined mailbox. Returns an empty string when no mailbox is selected. ### Imap.SendBufferSize `Chilkat 11.7.0 · ckruby · Imap · SendBufferSize · property · read/write` ```ruby # intVal is an integer intVal = imap.get_SendBufferSize(); imap.put_SendBufferSize(intVal); ``` Specifies the application-level buffer size used when sending data through the underlying TCP connection. The default is `32767` bytes. Most applications should leave this setting unchanged. ### Imap.SeparatorChar `Chilkat 11.7.0 · ckruby · Imap · SeparatorChar · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_SeparatorChar(ckStr); strVal = imap.separatorChar(); imap.put_SeparatorChar(strVal); ``` Contains the mailbox-hierarchy delimiter reported by the IMAP server, typically `/` or `.`. `MbxList` and the legacy mailbox-listing methods update this property from the server's LIST response. The value is a string containing one character. ### Imap.SessionLog `Chilkat 11.7.0 · ckruby · Imap · SessionLog · property · read-only` ```ruby # strVal is a string # ckStr is a CkString imap.get_SessionLog(ckStr); strVal = imap.sessionLog(); ``` Contains the in-memory log of raw IMAP commands and server responses. `KeepSessionLog` must be `true` for logging to occur. Call `ClearSessionLog` to remove previously collected entries. Chilkat redacts sensitive credentials, including passwords and OAuth access tokens, from session logs, diagnostic logs, and `LastErrorText`. ### Imap.SocksHostname `Chilkat 11.7.0 · ckruby · Imap · SocksHostname · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_SocksHostname(ckStr); strVal = imap.socksHostname(); imap.put_SocksHostname(strVal); ``` Specifies the hostname or numeric IP address of the SOCKS proxy. This property is used only when `SocksVersion` is `4` or `5`. ### Imap.SocksPassword `Chilkat 11.7.0 · ckruby · Imap · SocksPassword · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_SocksPassword(ckStr); strVal = imap.socksPassword(); imap.put_SocksPassword(strVal); ``` Specifies the SOCKS5 proxy password. It is ignored for SOCKS4 because SOCKS4 does not define password authentication. ### Imap.SocksPort `Chilkat 11.7.0 · ckruby · Imap · SocksPort · property · read/write` ```ruby # intVal is an integer intVal = imap.get_SocksPort(); imap.put_SocksPort(intVal); ``` Specifies the SOCKS proxy port. The default is `1080`. This property is used only when `SocksVersion` is `4` or `5`. ### Imap.SocksUsername `Chilkat 11.7.0 · ckruby · Imap · SocksUsername · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_SocksUsername(ckStr); strVal = imap.socksUsername(); imap.put_SocksUsername(strVal); ``` Specifies the username sent to a SOCKS4 or SOCKS5 proxy. This property is used only when `SocksVersion` is `4` or `5`. ### Imap.SocksVersion `Chilkat 11.7.0 · ckruby · Imap · SocksVersion · property · read/write` ```ruby # intVal is an integer intVal = imap.get_SocksVersion(); imap.put_SocksVersion(intVal); ``` Selects whether the IMAP connection uses a SOCKS proxy. | Value | Behavior | | --- | --- | | `0` | Do not use a SOCKS proxy. This is the default. | | `4` | Connect through a SOCKS4 proxy. | | `5` | Connect through a SOCKS5 proxy. | ### Imap.SoRcvBuf `Chilkat 11.7.0 · ckruby · Imap · SoRcvBuf · property · read/write` ```ruby # intVal is an integer intVal = imap.get_SoRcvBuf(); imap.put_SoRcvBuf(intVal); ``` Sets the operating system's TCP receive-buffer size. The default is `4194304` bytes. Most applications should leave this unchanged. Increasing it may improve download throughput on high-latency or high-bandwidth networks. Values that are multiples of `4096` are recommended. See also: - [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446) ### Imap.SortCriteria `Chilkat 11.7.0 · ckruby · Imap · SortCriteria · property · read/write · since 11.0.0` ```ruby # strVal is a string # ckStr is a CkString imap.get_SortCriteria(ckStr); strVal = imap.sortCriteria(); imap.put_SortCriteria(strVal); ``` Specifies the sort order used by `QueryMbx`. The default is the empty string, which uses an ordinary IMAP `SEARCH`. Set this property to a space-separated list of sort keys. Sorting is ascending unless `REVERSE` precedes a key. Supported keys are `ARRIVAL`, `CC`, `DATE`, `FROM`, `SIZE`, `SUBJECT`, and `TO`. Examples: - `SUBJECT REVERSE DATE` - `REVERSE SIZE` - `ARRIVAL` If the server does not support the IMAP `SORT` extension, Chilkat automatically falls back to an ordinary `SEARCH`. ### Imap.SoSndBuf `Chilkat 11.7.0 · ckruby · Imap · SoSndBuf · property · read/write` ```ruby # intVal is an integer intVal = imap.get_SoSndBuf(); imap.put_SoSndBuf(intVal); ``` Sets the operating system's TCP send-buffer size. The default is `262144` bytes. Most applications should leave this unchanged. Increasing it may improve upload throughput; values such as `524288` or `1048576` may be tested when needed. See also: - [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446) ### Imap.Ssl `Chilkat 11.7.0 · ckruby · Imap · Ssl · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_Ssl(); imap.put_Ssl(boolVal); ``` Controls implicit TLS for the IMAP connection. The default is `false`. - `true`: begin the connection with a TLS handshake, typically on port `993`. - `false`: begin with ordinary IMAP. Use `StartTls` when the server requires an explicit STARTTLS upgrade. If both this property and `StartTls` are `true`, implicit TLS takes precedence and STARTTLS is not used. ### Imap.SslAllowedCiphers `Chilkat 11.7.0 · ckruby · Imap · SslAllowedCiphers · property · read/write · since 9.5.0.48` ```ruby # strVal is a string # ckStr is a CkString imap.get_SslAllowedCiphers(ckStr); strVal = imap.sslAllowedCiphers(); imap.put_SslAllowedCiphers(strVal); ``` Restricts the cipher suites and selected TLS security requirements offered for an IMAP TLS connection. Leave this property empty to allow all cipher suites implemented by the installed Chilkat version. To restrict negotiation, provide a comma-separated list in preference order, for example: ``` TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 ``` The server chooses from the cipher suites offered by the client; the client cannot force a suite the server does not support. The list may also contain these policy keywords: - `rsa1024` or `rsa2048` to require a minimum RSA server-key size. - `secure-renegotiation` to require secure TLS renegotiation. - `best-practices` to use the security policy recommended by the installed Chilkat version. Legacy keywords such as `aes256-cbc`, `aes128-cbc`, `3des-cbc`, and `rc4` remain recognized for compatibility, but explicitly listing acceptable suites is preferred. ### Imap.SslProtocol `Chilkat 11.7.0 · ckruby · Imap · SslProtocol · property · read/write` ```ruby # strVal is a string # ckStr is a CkString imap.get_SslProtocol(ckStr); strVal = imap.sslProtocol(); imap.put_SslProtocol(strVal); ``` Selects the TLS protocol version or minimum version allowed for secure IMAP connections. The complete list of accepted values is: - `default` - `TLS 1.3` - `TLS 1.2` - `TLS 1.1` - `TLS 1.0` - `SSL 3.0` - `TLS 1.3 or higher` - `TLS 1.2 or higher` - `TLS 1.1 or higher` - `TLS 1.0 or higher` The default is `default`, which allows Chilkat to negotiate a protocol supported by both client and server. A minimum-version setting is generally more interoperable than requiring one exact version. ### Imap.SslServerCertVerified `Chilkat 11.7.0 · ckruby · Imap · SslServerCertVerified · property · read-only` ```ruby # boolVal is a boolean boolVal = imap.get_SslServerCertVerified(); ``` Indicates whether the IMAP server certificate chain was successfully verified for the current or most recent TLS connection. This property reports certificate-chain verification only. It does not report hostname matching or public-key pinning. If hostname matching or pinning is required and the check fails, the connection itself fails. ### Imap.StartTls `Chilkat 11.7.0 · ckruby · Imap · StartTls · property · read/write` ```ruby # boolVal is a boolean boolVal = imap.get_StartTls(); imap.put_StartTls(boolVal); ``` Controls explicit TLS using the IMAP `STARTTLS` command. The default is `false`. - `true`: connect in clear text, issue `STARTTLS`, and then continue through an encrypted channel. - `false`: do not request an explicit TLS upgrade. Explicit TLS is commonly used on port `143`. For implicit TLS, set `Ssl` to `true` and normally use port `993`. If both properties are `true`, `Ssl` takes precedence. ### Imap.TlsCipherSuite `Chilkat 11.7.0 · ckruby · Imap · TlsCipherSuite · property · read-only · since 9.5.0.49` ```ruby # strVal is a string # ckStr is a CkString imap.get_TlsCipherSuite(ckStr); strVal = imap.tlsCipherSuite(); ``` Contains the cipher suite negotiated for the current or most recent TLS connection, for example `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`. The value is empty before a TLS connection has been established or after a failed TLS negotiation. ### Imap.TlsPinSet `Chilkat 11.7.0 · ckruby · Imap · TlsPinSet · property · read/write · since 9.5.0.55` ```ruby # strVal is a string # ckStr is a CkString imap.get_TlsPinSet(ckStr); strVal = imap.tlsPinSet(); imap.put_TlsPinSet(strVal); ``` **Full documentation for this property (same in every language):** [Encodings Supported by Chilkat](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) Specifies one or more expected SPKI fingerprints for TLS public-key pinning. If none of the configured pins matches the server certificate, the TLS handshake fails. Pinning supplements normal certificate-chain verification; it does not replace it. A matching pin does not make an expired or otherwise invalid certificate acceptable. When a pin set is configured, pin matching is enforced even if `RequireSslCertVerify` is `false`. The format is: ``` hashAlgorithm, encoding, fingerprint1, fingerprint2, ... ``` Example: ``` sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE= ``` Supported hash algorithms include `sha1`, `sha256`, `sha384`, `sha512`, `md2`, `md5`, `haval`, `ripemd128`, `ripemd160`, `ripemd256`, and `ripemd320`. Supported encodings include `base64`, `hex`, and other Chilkat-supported binary encodings. ### Imap.TlsVersion `Chilkat 11.7.0 · ckruby · Imap · TlsVersion · property · read-only · since 9.5.0.49` ```ruby # strVal is a string # ckStr is a CkString imap.get_TlsVersion(ckStr); strVal = imap.tlsVersion(); ``` Contains the protocol version negotiated for the current or most recent TLS connection, such as `TLS 1.2` or `TLS 1.3`. The value is empty before a TLS connection has been established or after a failed TLS negotiation. ### Imap.UidNext `Chilkat 11.7.0 · ckruby · Imap · UidNext · property · read-only` ```ruby # intVal is a unsigned long intVal = imap.get_UidNext(); ``` Contains the mailbox's reported `UIDNEXT` value—the UID expected to be assigned to the next appended message. The value is `0` when no mailbox is selected or when the server did not provide `UIDNEXT`. ### Imap.UidValidity `Chilkat 11.7.0 · ckruby · Imap · UidValidity · property · read-only` ```ruby # intVal is a unsigned long intVal = imap.get_UidValidity(); ``` Contains the `UIDVALIDITY` value of the currently selected mailbox, or `0` when no mailbox is selected. An application that stores message UIDs should also store this value. If `UIDVALIDITY` changes in a later session, previously stored UIDs must no longer be assumed to identify the same messages. ### Imap.UncommonOptions `Chilkat 11.7.0 · ckruby · Imap · UncommonOptions · property · read/write · since 9.5.0.80` ```ruby # strVal is a string # ckStr is a CkString imap.get_UncommonOptions(ckStr); strVal = imap.uncommonOptions(); imap.put_UncommonOptions(strVal); ``` Provides comma-separated compatibility or platform-specific options for uncommon cases. The default is an empty string, and most applications should leave it unchanged. - `ProtectFromVpn`: on Android, bypasses an installed or active VPN. - `EnableTls13`: legacy option that enabled offering TLS 1.3 in versions where it was not yet enabled by default. ## Methods ### Imap.AddPfxSourceBd `Chilkat 11.7.0 · ckruby · Imap · AddPfxSourceBd · method · since 11.0.0` ```ruby # bd is a CkBinData # password is a string status = imap.AddPfxSourceBd(bd, password); ``` Adds the PKCS #12/PFX data in the `BinData` in `bd` as a source of certificates and private keys for S/MIME processing. `password` contains the PFX password. Call this method once for each additional source. Returns true for success, false for failure. ### Imap.AddPfxSourceFile `Chilkat 11.7.0 · ckruby · Imap · AddPfxSourceFile · method` ```ruby # pfxFilePath is a string # pfxPassword is a string status = imap.AddPfxSourceFile(pfxFilePath, pfxPassword); ``` Adds a PKCS #12/PFX file that may be searched for certificates and private keys needed for S/MIME decryption or signature processing. `pfxFilePath` is the local filesystem path of the PFX file, and `pfxPassword` contains its password. Call this method once for each additional source. On Windows, system certificate stores are also searched automatically. On macOS, the Keychain is searched automatically. Returns true for success, false for failure. ### Imap.AppendMail `Chilkat 11.7.0 · ckruby · Imap · AppendMail · method` ```ruby # mailbox is a string # email is a CkEmail status = imap.AppendMail(mailbox, email); ``` Appends the `Email` in `email` to the mailbox named by `mailbox`. `AppendSeen` controls the initial `\Seen` flag. After success, `AppendUid` contains the UID reported by the server, or `0` if no UID was reported, and `LastAppendedMime` contains the MIME sent. Rendering for the append does not generate or replace `email`'s `Date`, `Message-ID`, or MIME boundary values. If `email` uses an `8bit` or `binary` transfer encoding that would produce non-text binary bytes, Chilkat changes the rendered transfer encoding to a text-safe encoding such as Base64. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `AppendMailAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.AppendMime `Chilkat 11.7.0 · ckruby · Imap · AppendMime · method` ```ruby # mailbox is a string # mimeText is a string status = imap.AppendMime(mailbox, mimeText); ``` Appends the complete RFC 822/MIME message in `mimeText` to the mailbox named by `mailbox`. `AppendSeen` controls the initial `\Seen` flag. After success, `AppendUid` contains the UID reported by the server, or `0` if no UID was reported, and `LastAppendedMime` contains the MIME sent. The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary bytes. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `AppendMimeAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.AppendMimeWithDateStr `Chilkat 11.7.0 · ckruby · Imap · AppendMimeWithDateStr · method` ```ruby # mailbox is a string # mimeText is a string # internalDateStr is a string status = imap.AppendMimeWithDateStr(mailbox, mimeText, internalDateStr); ``` Appends the MIME message in `mimeText` to the mailbox named by `mailbox` while explicitly setting the server-side internal date from `internalDateStr`. `internalDateStr` is an RFC 822 date/time string, for example `Fri, 10 Jul 2026 20:15:30 GMT`. The internal date is mailbox metadata and is distinct from the message's `Date` header. `AppendSeen` controls the initial `\Seen` flag. The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary bytes. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `AppendMimeWithDateStrAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.AppendMimeWithFlags `Chilkat 11.7.0 · ckruby · Imap · AppendMimeWithFlags · method` ```ruby # mailbox is a string # mimeText is a string # seen is a boolean # flagged is a boolean # answered is a boolean # draft is a boolean status = imap.AppendMimeWithFlags(mailbox, mimeText, seen, flagged, answered, draft); ``` Appends the MIME message in `mimeText` to the mailbox named by `mailbox` and sets its initial system flags. - `seen` controls `\Seen`. - `flagged` controls `\Flagged`. - `answered` controls `\Answered`. - `draft` controls `\Draft`. Use `true` to set a flag and `false` to leave it unset. The explicit flag arguments are used instead of `AppendSeen`. The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary bytes. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `AppendMimeWithFlagsAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.AppendMimeWithFlagsSb `Chilkat 11.7.0 · ckruby · Imap · AppendMimeWithFlagsSb · method · since 9.5.0.62` ```ruby # mailbox is a string # sbMime is a CkStringBuilder # seen is a boolean # flagged is a boolean # answered is a boolean # draft is a boolean status = imap.AppendMimeWithFlagsSb(mailbox, sbMime, seen, flagged, answered, draft); ``` Appends the MIME contained in the `StringBuilder` in `sbMime` to mailbox `mailbox` and sets its initial system flags. - `seen` controls `\Seen`. - `flagged` controls `\Flagged`. - `answered` controls `\Answered`. - `draft` controls `\Draft`. The explicit flag arguments are used instead of `AppendSeen`. The MIME text is sent exactly as supplied. Chilkat does not normalize line endings, add a final CRLF, or re-encode headers or body content. The supplied text must not contain non-text binary bytes. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `AppendMimeWithFlagsSbAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Capability `Chilkat 11.7.0 · ckruby · Imap · Capability · method` ```ruby # outStr is a CkString (output) status = imap.Capability(outStr); retStr = imap.capability(); ``` Sends the IMAP `CAPABILITY` command and returns the server's raw capability response. Use `HasCapability` to test the returned text for a particular capability such as `IDLE`, `MOVE`, `SORT`, or `QUOTA`. Returns true for success, false for failure. Async variant: `CapabilityAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.CheckConnection `Chilkat 11.7.0 · ckruby · Imap · CheckConnection · method · since 9.5.0.46` ```ruby retBool = imap.CheckConnection(); ``` Checks whether the underlying TCP socket is currently connected to the IMAP server. This performs a low-level socket-state check and does not send an IMAP command. To verify that the server is responsive and the session remains usable, call `Noop`. ### Imap.ClearSessionLog `Chilkat 11.7.0 · ckruby · Imap · ClearSessionLog · method` ```ruby imap.ClearSessionLog(); ``` Clears the in-memory text returned by `SessionLog`. Session logging remains enabled or disabled according to `KeepSessionLog`. ### Imap.CloseMailbox `Chilkat 11.7.0 · ckruby · Imap · CloseMailbox · method` ```ruby # mailbox is a string status = imap.CloseMailbox(mailbox); ``` Closes the currently selected mailbox while keeping the authenticated IMAP connection open. `mailbox` is retained for backward compatibility but is ignored. It may be the empty string. Messages marked with `\Deleted` are permanently removed as part of the close operation. After success, `SelectedMailbox` is empty, but another mailbox can be selected on the same connection. Returns true for success, false for failure. Async variant: `CloseMailboxAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Connect `Chilkat 11.7.0 · ckruby · Imap · Connect · method` ```ruby # domainName is a string status = imap.Connect(domainName); ``` Establishes a TCP connection to the IMAP server identified by `domainName` but does not authenticate. `domainName` may be a hostname, IPv4 address, or IPv6 address. Configure `Port`, `Ssl`, `StartTls`, proxy settings, and timeouts before calling this method. The TLS hostname is used for Server Name Indication (SNI) and certificate hostname comparison. Call `Login` after the connection succeeds. If this method is called while already connected, Chilkat tears down the existing connection and establishes a new connection to `domainName`. This applies even when `domainName` names the same server. Imap does not automatically reconnect after a connection is dropped. The application must call this method again, authenticate again, reselect a mailbox when needed, and retry the interrupted operation. Connection failures can also be caused by DNS, local or remote firewalls, antivirus software, routing, or other network infrastructure outside Chilkat. Returns true for success, false for failure. Async variant: `ConnectAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Copy `Chilkat 11.7.0 · ckruby · Imap · Copy · method` ```ruby # msgId is an integer # bUid is a boolean # copyToMailbox is a string status = imap.Copy(msgId, bUid, copyToMailbox); ``` Copies one message from the currently selected mailbox to the destination mailbox in `copyToMailbox`. `msgId` identifies the source message. If `bUid` is `true`, `msgId` is a UID; otherwise, `msgId` is a sequence number. The original message remains in the selected mailbox. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `CopyAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.CopyMultiple `Chilkat 11.7.0 · ckruby · Imap · CopyMultiple · method` ```ruby # messageSet is a CkMessageSet # copyToMailbox is a string status = imap.CopyMultiple(messageSet, copyToMailbox); ``` Copies the messages identified by the `MessageSet` in `messageSet` from the selected mailbox to destination mailbox `copyToMailbox` using one IMAP command. `MessageSet.HasUids` determines whether `messageSet` contains UIDs or sequence numbers. For sequence numbers, one invalid value causes the entire command to fail and no messages are copied. For UIDs, nonexistent values are silently ignored and valid messages are copied. The original messages remain in the selected mailbox. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `CopyMultipleAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.CopySequence `Chilkat 11.7.0 · ckruby · Imap · CopySequence · method` ```ruby # startSeqNum is an integer # count is an integer # copyToMailbox is a string status = imap.CopySequence(startSeqNum, count, copyToMailbox); ``` **Full documentation for this method (same in every language):** [IMAP Sequence Numbers Explained](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/imap_message_sequence_numbers.md) Copies a contiguous range of messages, identified by sequence number, from the selected mailbox to the destination mailbox in `copyToMailbox`. `startSeqNum` is the first sequence number and `count` is the number of messages to copy. IMAP sequence numbers begin at `1` and can change when messages are expunged. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `CopySequenceAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.CreateMailbox `Chilkat 11.7.0 · ckruby · Imap · CreateMailbox · method` ```ruby # mailbox is a string status = imap.CreateMailbox(mailbox); ``` Creates the mailbox named by `mailbox` on the IMAP server. Use the hierarchy delimiter reported in `SeparatorChar` when creating a nested mailbox. In IMAP terminology, *mailbox* and *folder* are synonymous. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `CreateMailboxAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.DeleteMailbox `Chilkat 11.7.0 · ckruby · Imap · DeleteMailbox · method` ```ruby # mailbox is a string status = imap.DeleteMailbox(mailbox); ``` Deletes the mailbox named by `mailbox` from the IMAP server. This deletes the mailbox itself, not merely the messages it contains. Server rules may require the mailbox to be empty first. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `DeleteMailboxAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Disconnect `Chilkat 11.7.0 · ckruby · Imap · Disconnect · method` ```ruby status = imap.Disconnect(); ``` Closes the connection to the IMAP server. A failure indicates that the connection could not be closed cleanly; the socket is nevertheless no longer intended for further use. In many applications, a disconnect failure during shutdown can be treated as nonfatal. Returns true for success, false for failure. Async variant: `DisconnectAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.ExamineMailbox `Chilkat 11.7.0 · ckruby · Imap · ExamineMailbox · method` ```ruby # mailbox is a string status = imap.ExamineMailbox(mailbox); ``` Opens the mailbox in `mailbox` as read-only. Use this instead of `SelectMailbox` when the application must not change message flags or mailbox state. Successful examination updates properties such as `NumMessages`, `UidValidity`, and `UidNext`. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `ExamineMailboxAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Expunge `Chilkat 11.7.0 · ckruby · Imap · Expunge · method` ```ruby status = imap.Expunge(); ``` Permanently removes all messages marked with the `\Deleted` flag from the currently selected mailbox. The mailbox remains selected and the authenticated connection remains open. Expunging can change sequence numbers for the remaining messages. Returns true for success, false for failure. Async variant: `ExpungeAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.ExpungeAndClose `Chilkat 11.7.0 · ckruby · Imap · ExpungeAndClose · method` ```ruby status = imap.ExpungeAndClose(); ``` Permanently removes all messages marked with `\Deleted` from the selected mailbox and then closes the mailbox. After success, `SelectedMailbox` is empty. The authenticated IMAP connection remains open and can be used to select another mailbox. Returns true for success, false for failure. Async variant: `ExpungeAndCloseAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchAttachment `Chilkat 11.7.0 · ckruby · Imap · FetchAttachment · method` ```ruby # emailObject is a CkEmail # attachmentIndex is an integer # saveToPath is a string status = imap.FetchAttachment(emailObject, attachmentIndex, saveToPath); ``` Obtains attachment `attachmentIndex` from the `Email` in `emailObject` and writes it to the filesystem path in `saveToPath`. Attachment indexes are zero-based. `saveToPath` may be a filename, a relative path ending in a filename, or an absolute path ending in a filename. Missing parent directories are not created. An existing file is overwritten. A failed operation should not leave a partial output file. If `emailObject` already contains the attachment bytes, the data is saved without contacting the IMAP server. If `emailObject` was fetched without attachment bodies, Chilkat uses its `ckx-imap-*` metadata to locate and download the requested MIME part. The same IMAP session is not required, and a copied `Email` can be used if the metadata is preserved. The corresponding mailbox must be selected when a server fetch is required. If `ckx-imap-isUid` is `YES`, the permanent UID is used and the operation can work after reconnecting. If it is `NO`, the stored value is a sequence number, which can identify a different message after an expunge. UID-based metadata is therefore preferred for deferred attachment operations. The method fails if the referenced message or MIME part no longer exists, such as after the message is moved or expunged. Related MIME parts used by an HTML body are not counted as ordinary attachments. Signed and encrypted messages are fetched in full because their complete MIME is required. Returns true for success, false for failure. Async variant: `FetchAttachmentAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchAttachmentBd `Chilkat 11.7.0 · ckruby · Imap · FetchAttachmentBd · method · since 9.5.0.62` ```ruby # email is a CkEmail # attachmentIndex is an integer # binData is a CkBinData status = imap.FetchAttachmentBd(email, attachmentIndex, binData); ``` Obtains attachment `attachmentIndex` from the `Email` in `email` and stores its bytes in the `BinData` in `binData`. Attachment indexes are zero-based. `binData` is always cleared first. On success it contains the complete attachment bytes; on failure it remains empty. See `FetchAttachment` for details about downloading attachment data not already present in `email`. Returns true for success, false for failure. Async variant: `FetchAttachmentBdAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchAttachmentSb `Chilkat 11.7.0 · ckruby · Imap · FetchAttachmentSb · method · since 9.5.0.62` ```ruby # email is a CkEmail # attachmentIndex is an integer # charset is a string # sb is a CkStringBuilder status = imap.FetchAttachmentSb(email, attachmentIndex, charset, sb); ``` Obtains text attachment `attachmentIndex` from the `Email` in `email`, decodes it using the charset in `charset`, and stores the text in the `StringBuilder` in `sb`. Attachment indexes are zero-based. `sb` is always cleared first. On success it contains the complete decoded attachment text; on failure it remains empty. Use this method only for text attachments. See `FetchAttachment` for details about downloading data not already present in `email`. Returns true for success, false for failure. Async variant: `FetchAttachmentSbAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchAttachmentString `Chilkat 11.7.0 · ckruby · Imap · FetchAttachmentString · method` ```ruby # emailObject is a CkEmail # attachmentIndex is an integer # charset is a string # outStr is a CkString (output) status = imap.FetchAttachmentString(emailObject, attachmentIndex, charset, outStr); retStr = imap.fetchAttachmentString(emailObject, attachmentIndex, charset); ``` Obtains text attachment `attachmentIndex` from the `Email` in `emailObject` and decodes its bytes using the character encoding named by `charset`. Use this only when the attachment contains text. Attachment indexes are zero-based. See `FetchAttachment` for information about downloading attachment data that is not already present in `emailObject`. Returns true for success, false for failure. Async variant: `FetchAttachmentStringAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchChunk2 `Chilkat 11.7.0 · ckruby · Imap · FetchChunk2 · method · since 11.0.0` ```ruby # seqnum is an integer # count is an integer # failedSet is a CkMessageSet # fetchedSet is a CkMessageSet # bundle is a CkEmailBundle status = imap.FetchChunk2(seqnum, count, failedSet, fetchedSet, bundle); ``` Attempts to download `count` full messages beginning with sequence number `seqnum`. `failedSet` and `fetchedSet` are cleared before use. `failedSet` receives sequence numbers that failed or were not yet fetched, `fetchedSet` receives sequence numbers fetched successfully, and both sets have `MessageSet.HasUids` set to `false`. Downloaded messages are appended to the `EmailBundle` in `bundle`, which is not cleared. Sequence numbers beyond the end of the mailbox are added to `failedSet`. The method can return success even when `failedSet` is nonempty; success indicates that the requested range was processed, not that every sequence number existed. If a network failure occurs, messages already fetched remain in `bundle`, `fetchedSet` retains the successfully fetched sequence numbers, and `failedSet` contains the failed and not-yet-fetched sequence numbers. Processing stops and the connection must be considered unusable. Returns true for success, false for failure. Async variant: `FetchChunk2Async` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchEmail `Chilkat 11.7.0 · ckruby · Imap · FetchEmail · method · since 11.0.0` ```ruby # headerOnly is a boolean # msgId is an integer # bUid is a boolean # email is a CkEmail status = imap.FetchEmail(headerOnly, msgId, bUid, email); ``` Downloads one message or its headers into the `Email` in `email`. - `headerOnly` = `true`: download headers only. - `headerOnly` = `false`: download the full message. - `bUid` = `true`: `msgId` is a UID. - `bUid` = `false`: `msgId` is a sequence number. On success, `email` is replaced with the fetched email. On failure, `email` remains unchanged. A header-only result contains no body or attachment bodies, but includes `ckx-imap-*` metadata for the message identifier, flags, total size, and attachment information. For a full download, ordinary attachment bodies are included according to `AutoDownloadAttachments`. `PeekMode` controls whether a full fetch sets `\Seen`; a header-only fetch does not set it. Returns true for success, false for failure. Async variant: `FetchEmailAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchFlags `Chilkat 11.7.0 · ckruby · Imap · FetchFlags · method` ```ruby # msgId is an integer # bUid is a boolean # outStrFlags is a CkString (output) status = imap.FetchFlags(msgId, bUid, outStr); retStr = imap.fetchFlags(msgId, bUid); ``` Returns the space-separated IMAP flags for the message identified by `msgId`. If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. A result might be `\Flagged \Seen $label1`. An existing message with no flags returns the empty string. A nonexistent message is an error. Returns true for success, false for failure. Async variant: `FetchFlagsAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchMsgSet `Chilkat 11.7.0 · ckruby · Imap · FetchMsgSet · method · since 11.0.0` ```ruby # headersOnly is a boolean # msgSet is a CkMessageSet # bundle is a CkEmailBundle status = imap.FetchMsgSet(headersOnly, msgSet, bundle); ``` Downloads the existing messages identified by the `MessageSet` in `msgSet` and appends them to the `EmailBundle` in `bundle`. `bundle` is not cleared. - `headersOnly` = `true`: download headers only. - `headersOnly` = `false`: download full messages, with ordinary attachments controlled by `AutoDownloadAttachments`. `MessageSet.HasUids` determines whether `msgSet` contains UIDs or sequence numbers. A `MessageSet` is a true set, so duplicate identifiers are collapsed before any command is sent. Identifiers that do not exist are omitted without causing the method to fail. Do not rely on insertion order; fetched messages are returned in the order supplied by the IMAP server, normally mailbox order. If a network failure occurs after some messages have been downloaded, those messages remain appended to `bundle`, fetching stops immediately, and the connection must be considered unusable. Reconnect, authenticate, and reselect the mailbox before retrying. Returns true for success, false for failure. Async variant: `FetchMsgSetAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchRange `Chilkat 11.7.0 · ckruby · Imap · FetchRange · method · since 11.0.0` ```ruby # headersOnly is a boolean # seqnum is an integer # count is an integer # bundle is a CkEmailBundle status = imap.FetchRange(headersOnly, seqnum, count, bundle); ``` Downloads `count` messages beginning with sequence number `seqnum` and appends them to the `EmailBundle` in `bundle`. `bundle` is not cleared. - `headersOnly` = `true`: download headers only. - `headersOnly` = `false`: download full messages, with ordinary attachments controlled by `AutoDownloadAttachments`. `seqnum` and `count` must both be greater than `0`. IMAP sequence numbers begin at `1`; passing `0` for `seqnum`, `0` for `count`, or a negative count fails without changing `bundle`. Only messages that exist in the requested sequence-number range are appended. Sequence numbers can change after messages are expunged. If a network failure occurs after some messages have been downloaded, those messages remain appended to `bundle`, fetching stops immediately, and the connection must be considered unusable. Returns true for success, false for failure. Async variant: `FetchRangeAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchSingleAsMime `Chilkat 11.7.0 · ckruby · Imap · FetchSingleAsMime · method` ```ruby # msgId is an integer # bUid is a boolean # outStrMime is a CkString (output) status = imap.FetchSingleAsMime(msgId, bUid, outStr); retStr = imap.fetchSingleAsMime(msgId, bUid); ``` Downloads one message and returns its MIME source as a string. If `bUid` is `true`, `msgId` is a UID; otherwise, `msgId` is a sequence number. Ordinary attachment bodies are included according to `AutoDownloadAttachments`. Chilkat interprets the received MIME bytes as UTF-8. MIME using Base64 or quoted-printable transfer encoding is safe because the encoded bytes are ASCII. Raw `8bit` or `binary` content, or unencoded text in another charset such as ISO-8859-1 or Shift_JIS, can be misinterpreted or cause an error. Use `FetchSingleBd` whenever byte-exact MIME is required. Returns true for success, false for failure. Async variant: `FetchSingleAsMimeAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchSingleAsMimeSb `Chilkat 11.7.0 · ckruby · Imap · FetchSingleAsMimeSb · method · since 9.5.0.62` ```ruby # msgId is an integer # bUid is a boolean # sbMime is a CkStringBuilder status = imap.FetchSingleAsMimeSb(msgId, bUid, sbMime); ``` Downloads one message's MIME into the `StringBuilder` in `sbMime`. If `bUid` is `true`, `msgId` is a UID; otherwise, `msgId` is a sequence number. Ordinary attachment bodies are included according to `AutoDownloadAttachments`. `sbMime` is cleared before the operation; on failure it remains empty. Chilkat interprets the received MIME bytes as UTF-8. MIME using Base64 or quoted-printable transfer encoding is safe because the encoded bytes are ASCII. Raw `8bit` or `binary` content, or unencoded text in another charset such as ISO-8859-1 or Shift_JIS, can be misinterpreted or cause an error. Use `FetchSingleBd` whenever byte-exact MIME is required. Returns true for success, false for failure. Async variant: `FetchSingleAsMimeSbAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchSingleBd `Chilkat 11.7.0 · ckruby · Imap · FetchSingleBd · method · since 9.5.0.76` ```ruby # msgId is an integer # bUid is a boolean # mimeData is a CkBinData status = imap.FetchSingleBd(msgId, bUid, mimeData); ``` Downloads one message's MIME bytes into the `BinData` in `mimeData`. If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. Ordinary attachment bodies are included according to `AutoDownloadAttachments`, and `PeekMode` controls whether the fetch sets `\Seen`. `mimeData` is cleared before the operation. On success it contains the downloaded MIME bytes; on failure it remains empty. Returns true for success, false for failure. Async variant: `FetchSingleBdAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.FetchSingleHeaderAsMime `Chilkat 11.7.0 · ckruby · Imap · FetchSingleHeaderAsMime · method` ```ruby # msgId is an integer # bUID is a boolean # outStr is a CkString (output) status = imap.FetchSingleHeaderAsMime(msgId, bUID, outStr); retStr = imap.fetchSingleHeaderAsMime(msgId, bUID); ``` Downloads and returns the MIME header block for one message, without downloading the body. If `bUID` is `true`, `msgId` is a UID; otherwise, `msgId` is a sequence number. Returns true for success, false for failure. Async variant: `FetchSingleHeaderAsMimeAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.GetMailAttachFilename `Chilkat 11.7.0 · ckruby · Imap · GetMailAttachFilename · method` ```ruby # email is a CkEmail # attachIndex is an integer # outStrFilename is a CkString (output) status = imap.GetMailAttachFilename(email, attachIndex, outStr); retStr = imap.getMailAttachFilename(email, attachIndex); ``` Returns the filename for attachment `attachIndex` represented by `email`. Attachment indexes are zero-based. This method can obtain the filename from `ckx-imap-*` metadata in a header-only email even when the attachment body has not been downloaded. Returns true for success, false for failure. See also: - [Getting Attachment Information](http://www.cknotes.com/?p=434) ### Imap.GetMailAttachSize `Chilkat 11.7.0 · ckruby · Imap · GetMailAttachSize · method` ```ruby # email is a CkEmail # attachIndex is an integer retInt = imap.GetMailAttachSize(email, attachIndex); ``` Returns the size in bytes of attachment `attachIndex` represented by `email`. Attachment indexes are zero-based. This method can obtain the size from `ckx-imap-*` metadata in a header-only email even when the attachment body has not been downloaded. See also: - [Getting Attachment Information](http://www.cknotes.com/?p=434) ### Imap.GetMailboxStatus `Chilkat 11.7.0 · ckruby · Imap · GetMailboxStatus · method · since 9.5.0.46` ```ruby # mailbox is a string # outStr is a CkString (output) status = imap.GetMailboxStatus(mailbox, outStr); retStr = imap.getMailboxStatus(mailbox); ``` Sends the IMAP `STATUS` command for the mailbox in `mailbox` and returns the reported values as XML attributes. - `messages`: total number of messages. - `recent`: messages having the `\Recent` flag. - `uidnext`: expected UID for the next appended message. - `uidvalidity`: mailbox UID-validity value. - `unseen`: messages without the `\Seen` flag. ``` ``` Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `GetMailboxStatusAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.GetMailFlag `Chilkat 11.7.0 · ckruby · Imap · GetMailFlag · method` ```ruby # email is a CkEmail # flagName is a string retInt = imap.GetMailFlag(email, flagName); ``` Returns the state of the flag named by `flagName` from the IMAP metadata stored in the `Email` in `email`. - `1`: the flag is set. - `0`: the flag is not set. - `-1`: the required `ckx-imap-*` metadata is missing. Standard flags include `\Seen`, `\Answered`, `\Flagged`, `\Draft`, and `\Deleted`. Custom keywords such as `$label1` or `NonJunk` are also supported. Integer-returning methods do not use `LastMethodSuccess` to report this condition; test the return value directly. ### Imap.GetMailNumAttach `Chilkat 11.7.0 · ckruby · Imap · GetMailNumAttach · method` ```ruby # email is a CkEmail retInt = imap.GetMailNumAttach(email); ``` Returns the number of ordinary attachments represented by `email`. This method also works with a header-only email or an email fetched while `AutoDownloadAttachments` was `false`. In those cases it reads the `ckx-imap-numAttach` metadata, even though the `Email` object's downloaded attachment count can be `0`. See also: - [Getting Attachment Information](http://www.cknotes.com/?p=434) ### Imap.GetMailSize `Chilkat 11.7.0 · ckruby · Imap · GetMailSize · method` ```ruby # email is a CkEmail retInt = imap.GetMailSize(email); ``` Returns the complete server-reported size of the `Email` in `email`, in bytes, including attachment data. This value may be available even when only the message headers were downloaded. ### Imap.GetQuota `Chilkat 11.7.0 · ckruby · Imap · GetQuota · method · since 9.5.0.58` ```ruby # quotaRoot is a string # outStr is a CkString (output) status = imap.GetQuota(quotaRoot, outStr); retStr = imap.getQuota(quotaRoot); ``` Sends the IMAP `GETQUOTA` command for the quota root in `quotaRoot` and returns the server response as JSON. The server must advertise the IMAP `QUOTA` capability. Returns true for success, false for failure. Async variant: `GetQuotaAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.GetQuotaRoot `Chilkat 11.7.0 · ckruby · Imap · GetQuotaRoot · method · since 9.5.0.58` ```ruby # mailboxName is a string # outStr is a CkString (output) status = imap.GetQuotaRoot(mailboxName, outStr); retStr = imap.getQuotaRoot(mailboxName); ``` Sends the IMAP `GETQUOTAROOT` command for the mailbox in `mailboxName` and returns the server response as JSON. The server must advertise the IMAP `QUOTA` capability. A response can contain both the mailbox-to-root mapping and the quota values: ``` { "QUOTAROOT": {"mailbox":"Inbox","root":"Mailbox"}, "QUOTA": {"root":"Mailbox","resource":"STORAGE","used":9,"max":256000} } ``` Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `GetQuotaRootAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.GetServerCert `Chilkat 11.7.0 · ckruby · Imap · GetServerCert · method · since 11.0.0` ```ruby # cert is a CkCert status = imap.GetServerCert(cert); ``` Stores the certificate presented by the IMAP server for the current or most recent TLS connection in the `Cert` object supplied as `cert`. This is useful for certificate inspection, diagnostics, or implementing application-specific trust checks. Returns true for success, false for failure. ### Imap.HasCapability `Chilkat 11.7.0 · ckruby · Imap · HasCapability · method · since 9.5.0.58` ```ruby # name is a string # capabilityResponse is a string retBool = imap.HasCapability(name, capabilityResponse); ``` Tests whether the capability named by `name` appears in the raw capability response in `capabilityResponse`. `capabilityResponse` is typically the string returned by `Capability`. Capability-name matching follows IMAP capability-token semantics. ### Imap.IdleCheck `Chilkat 11.7.0 · ckruby · Imap · IdleCheck · method · since 9.5.0.26` ```ruby # timeoutMs is an integer # outStr is a CkString (output) status = imap.IdleCheck(timeoutMs, outStr); retStr = imap.idleCheck(timeoutMs); ``` Waits up to `timeoutMs` milliseconds for unsolicited mailbox updates after `IdleStart` has entered IMAP IDLE mode. `timeoutMs` = `0` performs a strict poll: it checks for already available data and returns immediately. Positive values wait for up to the requested time, including very large values. If the connection is lost while waiting, the method fails. This method does not send a polling command. It consumes the notifications currently waiting on the existing connection and returns them as XML. A second call returns only notifications that arrived after the previous call. - `flags`: flags changed for a message. - `expunge`: a sequence number was removed. - `exists`: the mailbox message count changed. - `recent`: the recent-message count changed. - `raw`: an unrecognized response line retained for diagnostics. ``` 1151 ``` When no update is available, the result is ``. An `exists` notification does not automatically change `NumMessages`. Chilkat does not automatically refresh IDLE. The application should periodically call `IdleDone` and `IdleStart`, typically before 29 minutes have elapsed, to prevent servers with a 30-minute limit from dropping the connection. Returns true for success, false for failure. Async variant: `IdleCheckAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.IdleDone `Chilkat 11.7.0 · ckruby · Imap · IdleDone · method · since 9.5.0.26` ```ruby status = imap.IdleDone(); ``` Ends IMAP IDLE mode by sending the protocol's `DONE` continuation. The authenticated connection remains open and usable. Calling this method when IDLE is not active fails. Applications maintaining a long-lived IDLE connection should call this method shortly before the server's IDLE limit, commonly at about 29 minutes, and then immediately call `IdleStart` again. Returns true for success, false for failure. Async variant: `IdleDoneAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.IdleStart `Chilkat 11.7.0 · ckruby · Imap · IdleStart · method · since 9.5.0.26` ```ruby status = imap.IdleStart(); ``` Sends the IMAP `IDLE` command and begins listening for unsolicited mailbox updates. The session must be connected, authenticated, and have a mailbox selected with `SelectMailbox` or `ExamineMailbox`. The server must advertise the `IDLE` capability. Calling this method while IDLE is already active fails. While IDLE is active, any other method that sends an IMAP command also fails; call `IdleDone` first. Chilkat does not automatically renew IDLE. To avoid common server time limits, the application should end and restart IDLE before the server timeout, typically about every 29 minutes. Returns true for success, false for failure. Async variant: `IdleStartAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.IsConnected `Chilkat 11.7.0 · ckruby · Imap · IsConnected · method` ```ruby retBool = imap.IsConnected(); ``` Returns the last known connection state without sending data to the IMAP server. A `true` result does not prove that an idle connection is still usable. Call `Noop` to send a command and verify that the server responds. ### Imap.IsLoggedIn `Chilkat 11.7.0 · ckruby · Imap · IsLoggedIn · method` ```ruby retBool = imap.IsLoggedIn(); ``` Indicates whether this object is in an authenticated IMAP session. This reports the last known state and does not send a command to the server. ### Imap.LoadTaskCaller `Chilkat 11.7.0 · ckruby · Imap · LoadTaskCaller · method · since 9.5.0.80` ```ruby # task is a CkTask status = imap.LoadTaskCaller(task); ``` Associates this `Imap` object with the original `Imap` caller that created the asynchronous `Task` in `task`. This works with a task returned by any `Imap` async method, and the task does not need to be complete. The operation does not copy the caller's state; this object becomes another reference to the same underlying `Imap` state. Any previously associated state in this object is replaced. Use this when code has a `Task`—for example in a task-completed callback—but no longer has a reference to the object that started the async operation. Returns true for success, false for failure. ### Imap.Login `Chilkat 11.7.0 · ckruby · Imap · Login · method` ```ruby # loginName is a string # password is a string status = imap.Login(loginName, password); ``` Authenticates the connected IMAP session using the login name in `loginName` and the credential in `password`. Call `Connect` first. The mechanism is selected by `AuthMethod`. For `XOAUTH2`, `loginName` is the normal IMAP login name or email address and `password` is the raw OAuth 2.0 access token without a `Bearer` prefix. A failed XOAUTH2 login leaves the connection open so the application may correct the credentials and try again. Do not call this method again after the session is already authenticated. A repeated login attempt fails, although the existing authenticated session remains logged in. Returns true for success, false for failure. Async variant: `LoginAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [Non-standard Yahoo! IMAP Server Requirements](http://www.cknotes.com/?p=326) ### Imap.LoginSecure `Chilkat 11.7.0 · ckruby · Imap · LoginSecure · method · since 9.5.0.71` ```ruby # loginName is a CkSecureString # password is a CkSecureString status = imap.LoginSecure(loginName, password); ``` Authenticates the connected IMAP session using the `SecureString` login name in `loginName` and credential in `password`. This is the secure-string counterpart of `Login`. The authentication mechanism is selected by `AuthMethod`. For `XOAUTH2`, `loginName` contains the normal login name or email address and `password` contains the raw access token without a `Bearer` prefix. Returns true for success, false for failure. Async variant: `LoginSecureAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Logout `Chilkat 11.7.0 · ckruby · Imap · Logout · method` ```ruby status = imap.Logout(); ``` Sends the IMAP `LOGOUT` command and ends the authenticated session. The server normally closes the connection as part of a successful logout. Returns true for success, false for failure. Async variant: `LogoutAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.MbxList `Chilkat 11.7.0 · ckruby · Imap · MbxList · method · since 11.0.0` ```ruby # subscribed is a boolean # reference is a string # mbxPattern is a string # mboxes is a CkMailboxes status = imap.MbxList(subscribed, reference, mbxPattern, mboxes); ``` Lists matching mailboxes and appends them to the `Mailboxes` object in `mboxes`. `mboxes` is not cleared on success, so repeated calls on the same object can add duplicate entries. If the method fails, `mboxes` is unchanged. - `subscribed` = `true`: list only subscribed mailboxes. - `subscribed` = `false`: list all matching mailboxes. `reference` is the IMAP reference name, usually an empty string. `mbxPattern` is the mailbox pattern: `*` matches zero or more hierarchy levels, while `%` matches one hierarchy level. Applications may use normal Unicode mailbox names and patterns. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. The method also updates `SeparatorChar` from the server's response. Returns true for success, false for failure. Async variant: `MbxListAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.MoveMessages `Chilkat 11.7.0 · ckruby · Imap · MoveMessages · method · since 9.5.0.64` ```ruby # messageSet is a CkMessageSet # destFolder is a string status = imap.MoveMessages(messageSet, destFolder); ``` Moves the messages identified by the `MessageSet` in `messageSet` from the selected mailbox to destination mailbox `destFolder` using one IMAP `MOVE` command. The server must advertise the `MOVE` capability. If it does not, this method fails and does not emulate the operation with copy, delete, and expunge commands. `MessageSet.HasUids` determines whether `messageSet` contains UIDs or sequence numbers. For sequence numbers, one invalid value causes complete failure and nothing is moved. For UIDs, nonexistent values are silently ignored and valid messages are moved. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `MoveMessagesAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Noop `Chilkat 11.7.0 · ckruby · Imap · Noop · method` ```ruby status = imap.Noop(); ``` Sends the IMAP `NOOP` command and waits for the server response. This is useful for verifying that an existing authenticated connection is still responsive and for receiving unsolicited mailbox-state updates. Returns true for success, false for failure. Async variant: `NoopAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.QueryMbx `Chilkat 11.7.0 · ckruby · Imap · QueryMbx · method · since 11.0.0` ```ruby # criteria is a string # bUid is a boolean # msgSet is a CkMessageSet status = imap.QueryMbx(criteria, bUid, msgSet); ``` **Full documentation for this method (same in every language):** [Explaining the IMAP Search Criteria](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/imap_search_criteria.md) Searches the selected mailbox using the IMAP criteria in `criteria` and stores matching identifiers in the `MessageSet` in `msgSet`. On success, `msgSet` is replaced with the result. If `bUid` is `true`, `msgSet` contains UIDs and `MessageSet.HasUids` is `true`; otherwise, `msgSet` contains sequence numbers and `MessageSet.HasUids` is `false`. If the method fails, `msgSet` is unchanged. `SearchCharset` applies when the criteria contain non-ASCII text. For the special criterion `new-email`, Chilkat records each `UIDNEXT` received from `SELECT`, `EXAMINE`, or another IMAP response and uses it as the baseline for detecting later UIDs. If no `UIDNEXT` is available, Chilkat searches for messages having the `\Recent` flag. Results are always UIDs regardless of `bUid`, and an empty result clears `msgSet`. When `SortCriteria` is nonempty, Chilkat uses IMAP `SORT` if the server supports it. Otherwise, it automatically falls back to an ordinary `SEARCH`. Returns true for success, false for failure. Async variant: `QueryMbxAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.QueryThread `Chilkat 11.7.0 · ckruby · Imap · QueryThread · method · since 11.0.0` ```ruby # threadAlg is a string # searchCriteria is a string # bUid is a boolean # json is a CkJsonObject status = imap.QueryThread(threadAlg, searchCriteria, bUid, json); ``` Sends the IMAP `THREAD` command for the selected mailbox. `threadAlg` is the threading algorithm, commonly `ORDEREDSUBJECT` or `REFERENCES`. `searchCriteria` contains ordinary IMAP search criteria and is interpreted using `SearchCharset`. If `bUid` is `true`, message identifiers in the result are UIDs; otherwise, they are sequence numbers. On success, `json` is completely replaced with the thread hierarchy. On failure, `json` is unchanged; there is no partial-success JSON result. The returned JSON has a top-level `threads` array. Each element represents one thread, and nested arrays encode parent/child relationships. For example: ``` {"threads":[[1],[2],[3]]} ``` The server must advertise the IMAP `THREAD` capability and support the selected algorithm. Returns true for success, false for failure. Async variant: `QueryThreadAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.RawCommandBd `Chilkat 11.7.0 · ckruby · Imap · RawCommandBd · method · since 11.0.0` ```ruby # bdCmd is a CkBinData # bdResp is a CkBinData status = imap.RawCommandBd(bdCmd, bdResp); ``` Sends the raw IMAP command bytes in the `BinData` in `bdCmd` and stores the raw response bytes in `bdResp`. `bdCmd` contains the command without an IMAP command tag or trailing CRLF; Chilkat supplies both. `bdResp` is cleared and replaced with the response. Use raw commands only for rare server extensions that are not otherwise exposed by the API, have an expected one-line response, and do not change Imap object state such as the selected mailbox, message count, `UidNext`, or `UidValidity`. State-changing raw commands can leave cached properties inconsistent with the server. Returns true for success, false for failure. Async variant: `RawCommandBdAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.RefetchMailFlags `Chilkat 11.7.0 · ckruby · Imap · RefetchMailFlags · method` ```ruby # email is a CkEmail status = imap.RefetchMailFlags(email); ``` Fetches the current IMAP flags for the server message represented by `email` and updates its `ckx-imap-*` metadata headers. Chilkat reads the identifier from `ckx-imap-uid` and checks `ckx-imap-isUid` to determine whether it is a UID or sequence number. A copied `Email` can be used as long as this metadata is preserved. When `ckx-imap-isUid` is `NO`, the stored sequence number may identify a different message after an expunge. UID-based emails are preferred for later operations. Methods such as `GetMailFlag` read the refreshed flag metadata. Returns true for success, false for failure. Async variant: `RefetchMailFlagsAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.RenameMailbox `Chilkat 11.7.0 · ckruby · Imap · RenameMailbox · method` ```ruby # fromMailbox is a string # toMailbox is a string status = imap.RenameMailbox(fromMailbox, toMailbox); ``` Renames the mailbox in `fromMailbox` to the name in `toMailbox`. Changing hierarchy components can also move a mailbox within the server's folder tree, for example from `INBOX.old.project` to `INBOX.archive.project`. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `RenameMailboxAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SelectMailbox `Chilkat 11.7.0 · ckruby · Imap · SelectMailbox · method` ```ruby # mailbox is a string status = imap.SelectMailbox(mailbox); ``` Opens the mailbox in `mailbox` for read-write access. A mailbox must be selected before message fetch, search, flag, copy, move, or expunge operations that act on mailbox contents. Successful selection updates `SelectedMailbox`, `NumMessages`, `UidValidity`, and related mailbox-state properties. Use `ExamineMailbox` when read-only access is required. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `SelectMailboxAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [Selecting Public Folders](http://www.cknotes.com/?p=284) ### Imap.SendRawCommand `Chilkat 11.7.0 · ckruby · Imap · SendRawCommand · method` ```ruby # cmd is a string # outRawResponse is a CkString (output) status = imap.SendRawCommand(cmd, outStr); retStr = imap.sendRawCommand(cmd); ``` Sends the raw IMAP command text in `cmd` and returns the raw server response. Pass the command itself, such as `NOOP`, without an IMAP command tag or trailing CRLF. Chilkat generates the tag and command line termination. Use raw commands only for rare server extensions that are not otherwise exposed by the API, have an expected one-line response, and do not change Imap object state such as the selected mailbox, message count, `UidNext`, or `UidValidity`. State-changing raw commands can leave cached properties inconsistent with the server. Returns true for success, false for failure. Async variant: `SendRawCommandAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SetDecryptCert `Chilkat 11.7.0 · ckruby · Imap · SetDecryptCert · method · since 9.5.0.40` ```ruby # cert is a CkCert status = imap.SetDecryptCert(cert); ``` Specifies the `Cert` in `cert` for decrypting S/MIME messages downloaded by this `Imap` object. The certificate must have access to its associated private key. Use `SetDecryptCert2` when the private key is supplied separately. Returns true for success, false for failure. ### Imap.SetDecryptCert2 `Chilkat 11.7.0 · ckruby · Imap · SetDecryptCert2 · method` ```ruby # cert is a CkCert # key is a CkPrivateKey status = imap.SetDecryptCert2(cert, key); ``` Specifies the certificate in `cert` and its separately supplied `PrivateKey` in `key` for decrypting S/MIME messages. Use this when the certificate object does not already provide access to the private key. Returns true for success, false for failure. ### Imap.SetFlag `Chilkat 11.7.0 · ckruby · Imap · SetFlag · method` ```ruby # msgId is an integer # bUid is a boolean # flagName is a string # value is an integer status = imap.SetFlag(msgId, bUid, flagName, value); ``` Sets or clears one flag on the message identified by `msgId` in the selected mailbox. If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. `flagName` is the flag name, and `value` is `1` to set the flag or `0` to clear it. Standard flags include `\Deleted`, `\Seen`, `\Answered`, `\Flagged`, and `\Draft`. Server-supported custom keywords may also be used. Returns true for success, false for failure. Async variant: `SetFlagAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SetFlags `Chilkat 11.7.0 · ckruby · Imap · SetFlags · method` ```ruby # messageSet is a CkMessageSet # flagName is a string # value is an integer status = imap.SetFlags(messageSet, flagName, value); ``` Sets or clears one flag for every identifier in the `MessageSet` supplied in `messageSet`. `flagName` is the flag name, and `value` is `1` to set it or `0` to clear it. `MessageSet.HasUids` determines whether the identifiers are UIDs or sequence numbers. Chilkat sends one IMAP `STORE` or `UID STORE` command containing the complete identifier set. IMAP bulk flag changes are not atomic and have no all-or-nothing rollback. Changes applied before a failure remain applied. For UID-based operations, nonexistent UIDs are silently ignored as required by IMAP. For sequence-number operations, an out-of-range sequence number causes the server to return an error; whether valid sequence numbers in the same command were changed before that error is server-dependent. This method changes server state only. It does not update metadata in any previously fetched `Email` objects. Returns true for success, false for failure. Async variant: `SetFlagsAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SetMailFlag `Chilkat 11.7.0 · ckruby · Imap · SetMailFlag · method` ```ruby # email is a CkEmail # flagName is a string # value is an integer status = imap.SetMailFlag(email, flagName, value); ``` Sets or clears a flag for the server message represented by the `Email` in `email`. Chilkat reads the message identifier from `ckx-imap-uid` and uses `ckx-imap-isUid` to determine whether the value is a UID or sequence number. `flagName` is the flag name, and `value` is `1` to set it or `0` to clear it. The method fails if the required metadata is absent. A copied `Email` can be used as long as the metadata is preserved. When `ckx-imap-isUid` is `NO`, the stored value is a sequence number and may no longer identify the same message after an expunge. UID-based emails are preferred for operations performed later or after reconnecting. Setting `\Deleted` marks the message for deletion; call `Expunge` to remove it permanently. Returns true for success, false for failure. Async variant: `SetMailFlagAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SetQuota `Chilkat 11.7.0 · ckruby · Imap · SetQuota · method · since 9.5.0.58` ```ruby # quotaRoot is a string # resource is a string # quota is an integer status = imap.SetQuota(quotaRoot, resource, quota); ``` Sends the IMAP `SETQUOTA` command for quota root `quotaRoot`. `resource` is `STORAGE` to set the combined message-storage limit or `MESSAGE` to set the message-count limit. For `STORAGE`, `quota` is measured in units of 1024 octets; for example, `500000` represents approximately 500,000,000 bytes. The server must support the IMAP `QUOTA` extension and the requested resource type. Returns true for success, false for failure. Async variant: `SetQuotaAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SetSslClientCert `Chilkat 11.7.0 · ckruby · Imap · SetSslClientCert · method` ```ruby # cert is a CkCert status = imap.SetSslClientCert(cert); ``` Specifies the client certificate in `cert` for TLS client-certificate authentication. Most IMAP servers do not require a client certificate. When one is required, `cert` must provide access to the corresponding private key. Returns true for success, false for failure. ### Imap.SetSslClientCertPem `Chilkat 11.7.0 · ckruby · Imap · SetSslClientCertPem · method` ```ruby # pemDataOrFilename is a string # pemPassword is a string status = imap.SetSslClientCertPem(pemDataOrFilename, pemPassword); ``` Specifies a TLS client certificate and private key from PEM data or a PEM file. `pemDataOrFilename` may contain the PEM text itself or a local filesystem path to the PEM file; Chilkat detects which form was supplied. `pemPassword` contains the password when the private key is encrypted. Returns true for success, false for failure. ### Imap.SetSslClientCertPfx `Chilkat 11.7.0 · ckruby · Imap · SetSslClientCertPfx · method` ```ruby # pfxFilename is a string # pfxPassword is a string status = imap.SetSslClientCertPfx(pfxFilename, pfxPassword); ``` Specifies a TLS client certificate and private key from a PKCS #12/PFX file. `pfxFilename` is the local filesystem path of the `.pfx` or `.p12` file, and `pfxPassword` contains its password. Returns true for success, false for failure. ### Imap.SshAuthenticatePk `Chilkat 11.7.0 · ckruby · Imap · SshAuthenticatePk · method` ```ruby # sshLogin is a string # privateKey is a CkSshKey status = imap.SshAuthenticatePk(sshLogin, privateKey); ``` Authenticates the SSH tunnel using the username in `sshLogin` and the `SshKey` private key in `privateKey`. Call `SshOpenTunnel` first. The corresponding public key must already be authorized for `sshLogin` on the SSH server. After authentication, call `Connect` and `Login` for the IMAP server. Returns true for success, false for failure. Async variant: `SshAuthenticatePkAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SshAuthenticatePw `Chilkat 11.7.0 · ckruby · Imap · SshAuthenticatePw · method` ```ruby # sshLogin is a string # sshPassword is a string status = imap.SshAuthenticatePw(sshLogin, sshPassword); ``` Authenticates the SSH tunnel using the username in `sshLogin` and password in `sshPassword`. Call `SshOpenTunnel` first. After SSH authentication succeeds, call `Connect` and `Login`; the IMAP traffic then flows through the tunnel automatically. Returns true for success, false for failure. Async variant: `SshAuthenticatePwAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SshCloseTunnel `Chilkat 11.7.0 · ckruby · Imap · SshCloseTunnel · method · since 9.5.0.50` ```ruby status = imap.SshCloseTunnel(); ``` Closes the SSH tunnel opened by `SshOpenTunnel`. Any IMAP connection using that tunnel must no longer be used after the tunnel is closed. Returns true for success, false for failure. Async variant: `SshCloseTunnelAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.SshOpenTunnel `Chilkat 11.7.0 · ckruby · Imap · SshOpenTunnel · method · since 9.5.0.50` ```ruby # sshHostname is a string # sshPort is an integer status = imap.SshOpenTunnel(sshHostname, sshPort); ``` Connects to the SSH server in `sshHostname` on port `sshPort` and prepares an SSH tunnel for the later IMAP connection. Port `22` is the usual SSH port. After this succeeds, authenticate with `SshAuthenticatePw` or `SshAuthenticatePk`, then call `Connect` and `Login` for IMAP. Returns true for success, false for failure. Async variant: `SshOpenTunnelAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.StoreFlags `Chilkat 11.7.0 · ckruby · Imap · StoreFlags · method` ```ruby # msgId is an integer # bUid is a boolean # flagNames is a string # value is an integer status = imap.StoreFlags(msgId, bUid, flagNames, value); ``` Sets or clears multiple flags on one message in the selected mailbox. If `bUid` is `true`, `msgId` is a UID; otherwise, it is a sequence number. `flagNames` is a space-separated list such as `\Seen \Answered $label1`. `value` is `1` to set all listed flags or `0` to clear them. The operation uses IMAP `STORE` or `UID STORE` and is not transactional. A nonexistent UID can be silently ignored and the command can still succeed. An invalid sequence number causes failure. This method changes server state only and does not update metadata in previously fetched `Email` objects. Returns true for success, false for failure. Async variant: `StoreFlagsAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Subscribe `Chilkat 11.7.0 · ckruby · Imap · Subscribe · method` ```ruby # mailbox is a string status = imap.Subscribe(mailbox); ``` Subscribes the authenticated IMAP account to the mailbox named by `mailbox`. Subscription controls which mailboxes are returned by subscribed-mailbox listing operations; it does not create the mailbox. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `SubscribeAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.Unsubscribe `Chilkat 11.7.0 · ckruby · Imap · Unsubscribe · method` ```ruby # mailbox is a string status = imap.Unsubscribe(mailbox); ``` Removes the subscription to the mailbox named by `mailbox`. The mailbox itself and its messages are not deleted. Mailbox names may be supplied as normal Unicode strings. Chilkat automatically handles IMAP modified UTF-7 or UTF-8 mailbox-name encoding as required by the server. Returns true for success, false for failure. Async variant: `UnsubscribeAsync` — same arguments, returns a `Task` (see Async variants below). ### Imap.UseCertVault `Chilkat 11.7.0 · ckruby · Imap · UseCertVault · method · since 9.5.0.40` ```ruby # vault is a CkXmlCertVault status = imap.UseCertVault(vault); ``` Associates the `XmlCertVault` in `vault` with this `Imap` object as a source of certificates and private keys for S/MIME operations. Only one vault can be associated at a time. Calling this method again replaces the previously associated vault. Returns true for success, false for failure. ### Imap.UseSsh `Chilkat 11.7.0 · ckruby · Imap · UseSsh · method · since 9.5.0.55` ```ruby # ssh is a CkSsh status = imap.UseSsh(ssh); ``` Uses an already connected and authenticated `Ssh` object as the transport for subsequent IMAP connections. SSH supports multiple logical channels, so the same SSH connection may be shared by IMAP and other Chilkat objects. Call this method before `Connect`. Returns true for success, false for failure. ### Imap.UseSshTunnel `Chilkat 11.7.0 · ckruby · Imap · UseSshTunnel · method · since 9.5.0.50` ```ruby # tunnel is a CkSocket status = imap.UseSshTunnel(tunnel); ``` Uses the existing SSH tunnel represented by the `Socket` in `tunnel` for subsequent IMAP connections. This allows a tunnel to be shared with other objects. Call this method before `Connect`. Returns true for success, false for failure. ## Events and callbacks This binding has no event callbacks. For progress, percent-done or cancellation use the `*Async` variant of a method and poll the returned `Task` (`PercentDone`, `Finished`, `Cancel`). ## Async variants Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on. ```ruby # returns a CkTask # mailbox is a string # email is a CkEmail ret_task = imap.AppendMailAsync(mailbox, email); # returns a CkTask # mailbox is a string # mimeText is a string ret_task = imap.AppendMimeAsync(mailbox, mimeText); # returns a CkTask # mailbox is a string # mimeText is a string # internalDateStr is a string ret_task = imap.AppendMimeWithDateStrAsync(mailbox, mimeText, internalDateStr); # returns a CkTask # mailbox is a string # mimeText is a string # seen is a boolean # flagged is a boolean # answered is a boolean # draft is a boolean ret_task = imap.AppendMimeWithFlagsAsync(mailbox, mimeText, seen, flagged, answered, draft); # returns a CkTask # mailbox is a string # sbMime is a CkStringBuilder # seen is a boolean # flagged is a boolean # answered is a boolean # draft is a boolean ret_task = imap.AppendMimeWithFlagsSbAsync(mailbox, sbMime, seen, flagged, answered, draft); # returns a CkTask ret_task = imap.CapabilityAsync(); # returns a CkTask # mailbox is a string ret_task = imap.CloseMailboxAsync(mailbox); # returns a CkTask # domainName is a string ret_task = imap.ConnectAsync(domainName); # returns a CkTask # msgId is an integer # bUid is a boolean # copyToMailbox is a string ret_task = imap.CopyAsync(msgId, bUid, copyToMailbox); # returns a CkTask # messageSet is a CkMessageSet # copyToMailbox is a string ret_task = imap.CopyMultipleAsync(messageSet, copyToMailbox); # returns a CkTask # startSeqNum is an integer # count is an integer # copyToMailbox is a string ret_task = imap.CopySequenceAsync(startSeqNum, count, copyToMailbox); # returns a CkTask # mailbox is a string ret_task = imap.CreateMailboxAsync(mailbox); # returns a CkTask # mailbox is a string ret_task = imap.DeleteMailboxAsync(mailbox); # returns a CkTask ret_task = imap.DisconnectAsync(); # returns a CkTask # mailbox is a string ret_task = imap.ExamineMailboxAsync(mailbox); # returns a CkTask ret_task = imap.ExpungeAsync(); # returns a CkTask ret_task = imap.ExpungeAndCloseAsync(); # returns a CkTask # emailObject is a CkEmail # attachmentIndex is an integer # saveToPath is a string ret_task = imap.FetchAttachmentAsync(emailObject, attachmentIndex, saveToPath); # returns a CkTask # email is a CkEmail # attachmentIndex is an integer # binData is a CkBinData ret_task = imap.FetchAttachmentBdAsync(email, attachmentIndex, binData); # returns a CkTask # email is a CkEmail # attachmentIndex is an integer # charset is a string # sb is a CkStringBuilder ret_task = imap.FetchAttachmentSbAsync(email, attachmentIndex, charset, sb); # returns a CkTask # emailObject is a CkEmail # attachmentIndex is an integer # charset is a string ret_task = imap.FetchAttachmentStringAsync(emailObject, attachmentIndex, charset); # returns a CkTask # seqnum is an integer # count is an integer # failedSet is a CkMessageSet # fetchedSet is a CkMessageSet # bundle is a CkEmailBundle ret_task = imap.FetchChunk2Async(seqnum, count, failedSet, fetchedSet, bundle); # returns a CkTask # headerOnly is a boolean # msgId is an integer # bUid is a boolean # email is a CkEmail ret_task = imap.FetchEmailAsync(headerOnly, msgId, bUid, email); # returns a CkTask # msgId is an integer # bUid is a boolean ret_task = imap.FetchFlagsAsync(msgId, bUid); # returns a CkTask # headersOnly is a boolean # msgSet is a CkMessageSet # bundle is a CkEmailBundle ret_task = imap.FetchMsgSetAsync(headersOnly, msgSet, bundle); # returns a CkTask # headersOnly is a boolean # seqnum is an integer # count is an integer # bundle is a CkEmailBundle ret_task = imap.FetchRangeAsync(headersOnly, seqnum, count, bundle); # returns a CkTask # msgId is an integer # bUid is a boolean ret_task = imap.FetchSingleAsMimeAsync(msgId, bUid); # returns a CkTask # msgId is an integer # bUid is a boolean # sbMime is a CkStringBuilder ret_task = imap.FetchSingleAsMimeSbAsync(msgId, bUid, sbMime); # returns a CkTask # msgId is an integer # bUid is a boolean # mimeData is a CkBinData ret_task = imap.FetchSingleBdAsync(msgId, bUid, mimeData); # returns a CkTask # msgId is an integer # bUID is a boolean ret_task = imap.FetchSingleHeaderAsMimeAsync(msgId, bUID); # returns a CkTask # mailbox is a string ret_task = imap.GetMailboxStatusAsync(mailbox); # returns a CkTask # quotaRoot is a string ret_task = imap.GetQuotaAsync(quotaRoot); # returns a CkTask # mailboxName is a string ret_task = imap.GetQuotaRootAsync(mailboxName); # returns a CkTask # timeoutMs is an integer ret_task = imap.IdleCheckAsync(timeoutMs); # returns a CkTask ret_task = imap.IdleDoneAsync(); # returns a CkTask ret_task = imap.IdleStartAsync(); # returns a CkTask # loginName is a string # password is a string ret_task = imap.LoginAsync(loginName, password); # returns a CkTask # loginName is a CkSecureString # password is a CkSecureString ret_task = imap.LoginSecureAsync(loginName, password); # returns a CkTask ret_task = imap.LogoutAsync(); # returns a CkTask # subscribed is a boolean # reference is a string # mbxPattern is a string # mboxes is a CkMailboxes ret_task = imap.MbxListAsync(subscribed, reference, mbxPattern, mboxes); # returns a CkTask # messageSet is a CkMessageSet # destFolder is a string ret_task = imap.MoveMessagesAsync(messageSet, destFolder); # returns a CkTask ret_task = imap.NoopAsync(); # returns a CkTask # criteria is a string # bUid is a boolean # msgSet is a CkMessageSet ret_task = imap.QueryMbxAsync(criteria, bUid, msgSet); # returns a CkTask # threadAlg is a string # searchCriteria is a string # bUid is a boolean # json is a CkJsonObject ret_task = imap.QueryThreadAsync(threadAlg, searchCriteria, bUid, json); # returns a CkTask # bdCmd is a CkBinData # bdResp is a CkBinData ret_task = imap.RawCommandBdAsync(bdCmd, bdResp); # returns a CkTask # email is a CkEmail ret_task = imap.RefetchMailFlagsAsync(email); # returns a CkTask # fromMailbox is a string # toMailbox is a string ret_task = imap.RenameMailboxAsync(fromMailbox, toMailbox); # returns a CkTask # mailbox is a string ret_task = imap.SelectMailboxAsync(mailbox); # returns a CkTask # cmd is a string ret_task = imap.SendRawCommandAsync(cmd); # returns a CkTask # msgId is an integer # bUid is a boolean # flagName is a string # value is an integer ret_task = imap.SetFlagAsync(msgId, bUid, flagName, value); # returns a CkTask # messageSet is a CkMessageSet # flagName is a string # value is an integer ret_task = imap.SetFlagsAsync(messageSet, flagName, value); # returns a CkTask # email is a CkEmail # flagName is a string # value is an integer ret_task = imap.SetMailFlagAsync(email, flagName, value); # returns a CkTask # quotaRoot is a string # resource is a string # quota is an integer ret_task = imap.SetQuotaAsync(quotaRoot, resource, quota); # returns a CkTask # sshLogin is a string # privateKey is a CkSshKey ret_task = imap.SshAuthenticatePkAsync(sshLogin, privateKey); # returns a CkTask # sshLogin is a string # sshPassword is a string ret_task = imap.SshAuthenticatePwAsync(sshLogin, sshPassword); # returns a CkTask ret_task = imap.SshCloseTunnelAsync(); # returns a CkTask # sshHostname is a string # sshPort is an integer ret_task = imap.SshOpenTunnelAsync(sshHostname, sshPort); # returns a CkTask # msgId is an integer # bUid is a boolean # flagNames is a string # value is an integer ret_task = imap.StoreFlagsAsync(msgId, bUid, flagNames, value); # returns a CkTask # mailbox is a string ret_task = imap.SubscribeAsync(mailbox); # returns a CkTask # mailbox is a string ret_task = imap.UnsubscribeAsync(mailbox); ``` ## Deprecated members — do not use in new code | Member | Kind | Deprecated in | Use instead | |---|---|---|---| | `AddPfxSourceData` | method | before 11.6.1 | — | | `CheckForNewEmail` | method | before 11.6.1 | `QueryMbx` | | `FetchAttachmentBytes` | method | before 11.6.1 | — | | `FetchBundle` | method | before 11.6.1 | `FetchMsgSet` | | `FetchBundleAsMime` | method | before 11.6.1 | — | | `FetchChunk` | method | before 11.6.1 | `FetchRange` | | `FetchHeaders` | method | before 11.6.1 | `FetchMsgSet` | | `FetchSequence` | method | before 11.6.1 | `FetchRange` | | `FetchSequenceAsMime` | method | before 11.6.1 | — | | `FetchSequenceHeaders` | method | before 11.6.1 | `FetchRange` | | `FetchSingle` | method | before 11.6.1 | `FetchEmail` | | `FetchSingleHeader` | method | before 11.6.1 | `FetchEmail` | | `GetAllUids` | method | before 11.6.1 | `QueryMbx` | | `GetSslServerCert` | method | before 11.6.1 | `GetServerCert` | | `ListMailboxes` | method | before 11.6.1 | `MbxList` | | `ListSubscribed` | method | before 11.6.1 | `MbxList` | | `Search` | method | before 11.6.1 | `QueryMbx` | | `SendRawCommandB` | method | before 11.6.1 | — | | `SendRawCommandC` | method | before 11.6.1 | — | | `Sort` | method | before 11.6.1 | `QueryMbx` | | `ThreadCmd` | method | before 11.6.1 | `QueryThread` | ## Related classes [`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/BinData.md), [`Cert`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/Cert.md), [`Email`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/Email.md), [`EmailBundle`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/EmailBundle.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/JsonObject.md), [`Mailboxes`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/Mailboxes.md), [`MessageSet`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/MessageSet.md), [`PrivateKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/PrivateKey.md), [`SecureString`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/SecureString.md), [`Socket`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/Socket.md), [`Ssh`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/Ssh.md), [`SshKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/SshKey.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/StringBuilder.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/Task.md), [`XmlCertVault`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/ckruby/classes/XmlCertVault.md)