Issue #1258 - Part 1: Import mailnews, ldap, and mork from comm-esr52.9.1

20 files changed, 2002 insertions, 0 deletions

diff --git a/mailnews/imap/public/moz.build b/mailnews/imap/public/moz.build
new file mode 100644
index 000000000..c531cc82b
--- /dev/null
+++ b/mailnews/imap/public/moz.build
@@ -0,0 +1,32 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPIDL_SOURCES += [
+    'nsIAutoSyncFolderStrategy.idl',
+    'nsIAutoSyncManager.idl',
+    'nsIAutoSyncMsgStrategy.idl',
+    'nsIAutoSyncState.idl',
+    'nsIImapFlagAndUidState.idl',
+    'nsIImapHeaderXferInfo.idl',
+    'nsIImapIncomingServer.idl',
+    'nsIImapMailFolderSink.idl',
+    'nsIImapMessageSink.idl',
+    'nsIImapMockChannel.idl',
+    'nsIImapProtocol.idl',
+    'nsIImapProtocolSink.idl',
+    'nsIImapServerSink.idl',
+    'nsIImapService.idl',
+    'nsIImapUrl.idl',
+    'nsIMailboxSpec.idl',
+    'nsIMsgImapMailFolder.idl',
+]
+
+XPIDL_MODULE = 'msgimap'
+
+EXPORTS += [
+    'nsIIMAPHostSessionList.h',
+    'nsMsgImapCID.h',
+]
+
diff --git a/mailnews/imap/public/nsIAutoSyncFolderStrategy.idl b/mailnews/imap/public/nsIAutoSyncFolderStrategy.idl
new file mode 100644
index 000000000..d58b6085f
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncFolderStrategy.idl
@@ -0,0 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+#include "nsISupports.idl"
+#include "nsIAutoSyncMsgStrategy.idl"
+
+interface nsIMsgAccount;
+
+[scriptable, uuid(d3bf91cc-37bb-4752-9994-1a8473e46a90)] 
+interface nsIAutoSyncFolderStrategy : nsISupports {
+
+  /**
+   * Returns a relative-priority for the second folder by comparing with the first one.
+   */
+  nsAutoSyncStrategyDecisionType sort(in nsIMsgFolder aFolder1, in nsIMsgFolder aFolder2);
+  
+  /**
+   * Tests whether the given folder should be excluded or not.
+   */
+  boolean isExcluded(in nsIMsgFolder aFolder);
+
+};
diff --git a/mailnews/imap/public/nsIAutoSyncManager.idl b/mailnews/imap/public/nsIAutoSyncManager.idl
new file mode 100644
index 000000000..0dee48963
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncManager.idl
@@ -0,0 +1,194 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+#include "nsISupports.idl"
+
+interface nsIAutoSyncMsgStrategy;
+interface nsIAutoSyncFolderStrategy;
+interface nsIMsgDBHdr;
+interface nsIAutoSyncState;
+interface nsIAutoSyncMgrListener;
+interface nsIMsgFolder;
+interface nsIMsgAccount;
+
+[scriptable, uuid(41ec36a7-1a53-4ca3-b698-dca6452a8761)] 
+interface nsIAutoSyncMgrListener : nsISupports {
+
+  /**
+   * Queue types
+   */
+  const long PriorityQueue = 1;
+  const long UpdateQueue = 2;
+  const long DiscoveryQueue = 3;
+
+  /**
+   * It is called on the listener when a new folder is added into
+   * the queue
+   *
+   * @param aQType type of the queue
+   * @param aFolder folder that is added into the queue
+   */
+  void onFolderAddedIntoQ(in long aQType, in nsIMsgFolder aFolder);
+  
+  /**
+   * It is called on the listener when a folder is removed from
+   * the queue
+   *
+   * @param aQType type of the queue
+   * @param aFolder folder that is removed from the queue
+   */
+  void onFolderRemovedFromQ(in long aQType, in nsIMsgFolder aFolder);
+  
+  /**
+   * It is called on the listener when a message download is successfully started
+   *
+   * @param aFolder folder in which the download is started 
+   * @param aNumberOfMessages number of the messages that will be downloaded 
+   * @param aTotalPending  total number of messages waiting to be downloaded 
+   */
+  void onDownloadStarted(in nsIMsgFolder aFolder, in unsigned long aNumberOfMessages, 
+                         in unsigned long aTotalPending);
+  /**
+   * It is called on the listener when a message download on the given folder 
+   * is completed
+   */
+  void onDownloadCompleted(in nsIMsgFolder aFolder);
+  
+  /**
+   * It is called on the listener when an error occurs during the message download
+   */
+  void onDownloadError(in nsIMsgFolder aFolder);
+  
+  /*
+   * Auto-Sync manager is running or waiting for idle 
+   */
+  void onStateChanged(in boolean aRunning);
+  
+  /**
+   * It is called on the listener after the auto-sync manager starts to process 
+   * existing headers of the given folder to find missing message bodies
+   * (mostly for debugging purposes)
+   */
+  void onDiscoveryQProcessed(in nsIMsgFolder aFolder, in unsigned long aNumberOfHdrsProcessed, 
+                             in unsigned long aLeftToProcess);
+  
+  /**
+   * It is called on the listener after the auto-sync manager updates the given folder 
+   * (mostly for debugging purposes)
+   */
+  void onAutoSyncInitiated(in nsIMsgFolder aFolder);
+};
+
+
+[scriptable, uuid(7fe0b48e-f5d8-4747-beb7-888c9cced3a5)]
+interface nsIAutoSyncManager : nsISupports {
+
+  /** 
+   * Download models
+   */
+  const long dmParallel = 0;
+  const long dmChained = 1;
+
+  /**
+   * Suggested minimum grouping size in bytes for message downloads.
+   * Setting this attribute to 0 resets its value to the 
+   * hardcoded default.
+   */
+  attribute unsigned long groupSize;
+
+  /**
+   * Active strategy function to prioritize
+   * messages in the download queue
+   */
+  attribute nsIAutoSyncMsgStrategy msgStrategy;
+
+  /**
+   * Active strategy function to prioritize
+   * folders in the download queue
+   */
+  attribute nsIAutoSyncFolderStrategy folderStrategy;
+
+  /**
+   * Adds a listener to notify about auto-sync events
+   */
+  void addListener(in nsIAutoSyncMgrListener aListener);
+  
+  /**
+   * Removes the listener from notification list
+   */
+  void removeListener(in nsIAutoSyncMgrListener aListener);
+    
+  /**
+   * Tests the given message to make sure that whether 
+   * it fits the download criteria or not
+   */
+  boolean doesMsgFitDownloadCriteria(in nsIMsgDBHdr aMsgHdr);
+  
+  /**
+   * Called by the nsAutoSyncState object when the download
+   * queue is changed. Given interface is already addref'd.
+   */
+  void onDownloadQChanged(in nsIAutoSyncState aAutoSyncStateObj);
+  
+  /**
+   * Called by the nsAutoSyncState object when the download
+   * is started. Given interface is already addref'd.
+   */
+  void onDownloadStarted(in nsIAutoSyncState aAutoSyncStateObj, in nsresult aStartCode);
+  
+  /**
+   * Called by the nsAutoSyncState object when the download
+   * completed. Given interface is already addref'd.
+   */
+  void onDownloadCompleted(in nsIAutoSyncState aAutoSyncStateObj, in nsresult aExitCode);
+  
+  /**
+   * Number of elements in the discovery queue.
+   * @see nsAutoSyncManager.h for details
+   */
+  readonly attribute unsigned long discoveryQLength;
+  
+  /**
+   * Number of elements in the update queue.
+   * @see nsAutoSyncManager.h for details
+   */
+  readonly attribute unsigned long updateQLength;
+  
+  /**
+   * Number of elements in the download queue (a.k.a priority queue).
+   * @see nsAutoSyncManager.h for details
+   */
+  readonly attribute unsigned long downloadQLength;
+
+  /**
+   * Active download model; Chained (serial), or Parallel
+   */
+  attribute long downloadModel;
+
+  /**
+   * The imap folder corresponding to aAutoSyncState has had a message
+   * added to it. Autosync may want to add this folder to the update q.
+   *
+   * @param aAutoSyncState state obj for folder needing updating
+   */
+  void onFolderHasPendingMsgs(in nsIAutoSyncState aAutoSyncState);
+
+  /// Pause autosync (e.g., we're downloading for offline).
+  void pause();
+  
+  /// Resume normal autosync activities (e.g., we've come back online).
+  void resume();
+};
+
+%{C++
+#define NS_AUTOSYNCMANAGER_CID  \
+{ /* C358C568-47B2-42b2-8146-3C0F8D1FAD6E */  \
+  0xc358c568, 0x47b2, 0x42b2,                 \
+  { 0x81, 0x46, 0x3c, 0xf, 0x8d, 0x1f, 0xad, 0x6e }}
+#define NS_AUTOSYNCMANAGER_CLASSNAME \
+  "Auto-Sync Manager"
+#define NS_AUTOSYNCMANAGER_CONTRACTID \
+  "@mozilla.org/imap/autosyncmgr;1"
+%}
+
diff --git a/mailnews/imap/public/nsIAutoSyncMsgStrategy.idl b/mailnews/imap/public/nsIAutoSyncMsgStrategy.idl
new file mode 100644
index 000000000..93633a2cb
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncMsgStrategy.idl
@@ -0,0 +1,35 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+#include "nsISupports.idl"
+
+interface nsIMsgFolder;
+interface nsIMsgDBHdr;
+
+typedef long nsAutoSyncStrategyDecisionType;
+
+[scriptable,uuid(0365bec5-3753-43c2-b13e-441747815f37)]
+interface nsAutoSyncStrategyDecisions
+{
+  /// same priority
+  const nsAutoSyncStrategyDecisionType Same         = 0x00000001;
+  /// higher priority
+  const nsAutoSyncStrategyDecisionType Higher       = 0x00000002;
+  /// lower priority
+  const nsAutoSyncStrategyDecisionType Lower        = 0x00000004;
+};
+
+[scriptable, uuid(9cb4baff-3112-4cf8-8463-f81b0aa78f93)] 
+interface nsIAutoSyncMsgStrategy : nsISupports {
+
+  /**
+   * Returns a relative-priority for the second message by comparing with the first message.
+   */
+  nsAutoSyncStrategyDecisionType sort(in nsIMsgFolder aFolder, in nsIMsgDBHdr aMsgHdr1, in nsIMsgDBHdr aMsgHdr2);
+  
+  /**
+   * Tests whether the given message should be excluded or not.
+   */
+  boolean isExcluded(in nsIMsgFolder aFolder, in nsIMsgDBHdr aMsgHdr);
+};
diff --git a/mailnews/imap/public/nsIAutoSyncState.idl b/mailnews/imap/public/nsIAutoSyncState.idl
new file mode 100644
index 000000000..d03697e11
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncState.idl
@@ -0,0 +1,130 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIMsgFolder;
+interface nsIArray;
+interface nsIMutableArray;
+
+[scriptable, uuid(7512f927-b8f0-48c4-b101-03e859e61281)]
+interface nsIAutoSyncState : nsISupports {
+
+  /**
+   * Auto-Sync states.
+   *
+   * ***WARNING***: If you change these, be sure to update stateStrings in
+   * nsAutoSyncState.cpp. If you do not, out-of-bounds memory accesses may
+   * happen.
+   */
+
+  /** sync'd and no pending messages */
+  const long stCompletedIdle = 0;     
+
+  /** STATUS issued. Will check to see if  any counts changed since last STATUS */
+  const long stStatusIssued = 1;
+
+  /**
+   * Status found new messages. Update should be issued next. Status most
+   * likely was issued by non-autosync code (e.g., check other folders for
+   * new messages).
+   */
+  const long stUpdateNeeded = 2;
+
+  /** Update issued. Will figure out if there are any bodies to download */
+  const long stUpdateIssued = 3;
+
+  /** Message body download in progress */
+  const long stDownloadInProgress = 4;
+
+  /** ready to download the next group of messages */
+  const long stReadyToDownload = 5;
+
+  /**
+   * Puts the download queue offset to its previous position. 
+   */
+  void rollback();
+  
+  /**
+   * Clears the download queue. Resets the offsets.
+   */
+  void resetDownloadQ();
+  
+  /**
+   * Rollbacks the offset to the previous position and
+   * changes the state to ready-to-download.
+   */
+  void tryCurrentGroupAgain(in unsigned long aRetryCount);
+  
+  /**
+   * Resets the retry counter.
+   */
+  void resetRetryCounter();
+  
+  /**
+   * Tests whether the given folder has the same imap server. 
+   */
+  boolean isSibling(in nsIAutoSyncState aAnotherStateObj);
+
+  /**
+   * Update the folder to find new message headers to download
+   */
+  void updateFolder();
+
+  /**
+   * Downloads the bodies of the given messages from the server.
+   */
+  void downloadMessagesForOffline(in nsIArray aMessageList);
+
+  /**
+   * Populates the given array with the keys of the messages that will 
+   * be downloaded next.
+   *
+   * @param aSuggestedGroupSizeLimit suggested size per group in bytes
+   * @param aActualGroupSize total size of the messages in bytes in the group
+   */
+  nsIMutableArray getNextGroupOfMessages(in unsigned long aSuggestedGroupSizeLimit, 
+                                         out unsigned long aActualGroupSize);
+  
+  /**
+   * Iterates through the existing headers of the folder to find 
+   * the messages not downloaded yet. 
+   *
+   * @param aNumberOfHeadersToProcess number of headers to be processed
+   *                                  at this pass
+   *
+   * @return the number of headers left to process
+   */
+  unsigned long processExistingHeaders(in unsigned long aNumberOfHeadersToProcess);
+
+  /**
+   * Last time the existing headers are completely processed. 
+   */
+  [noscript]readonly attribute PRTime lastSyncTime;
+  
+  /**
+   * Last time the owner folder is updated.
+   */
+  [noscript]attribute PRTime lastUpdateTime;
+  
+  /**
+   * Download operation state. 
+   */
+  attribute long state;
+  
+  /**
+   * Number of messages waiting to be downloaded.
+   */
+  readonly attribute long pendingMessageCount;
+  
+  /**
+   * Total number of messages in the download queue.
+   */
+  readonly attribute long totalMessageCount;
+  
+  /**
+   * The folder this auto-sync object is related to.
+   */
+  readonly attribute nsIMsgFolder ownerFolder;
+};
diff --git a/mailnews/imap/public/nsIIMAPHostSessionList.h b/mailnews/imap/public/nsIIMAPHostSessionList.h
new file mode 100644
index 000000000..e3ce35d4f
--- /dev/null
+++ b/mailnews/imap/public/nsIIMAPHostSessionList.h
@@ -0,0 +1,100 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsIImapHostSessionList_H_
+#define _nsIImapHostSessionList_H_
+
+#include "nsISupports.h"
+#include "nsImapCore.h"
+
+class nsIMAPBodyShellCache;
+class nsIMAPBodyShell;
+class nsIImapIncomingServer;
+
+// f4d89e3e-77da-492c-962b-7835f0742c22
+#define NS_IIMAPHOSTSESSIONLIST_IID \
+{ 0xf4d89e3e, 0x77da, 0x492c, {0x96, 0x2b, 0x78, 0x35, 0xf0, 0x74, 0x2c, 0x22 } }
+
+// this is an interface to a linked list of host info's    
+class nsIImapHostSessionList : public nsISupports
+{
+public:
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IIMAPHOSTSESSIONLIST_IID)
+
+  // Host List
+  NS_IMETHOD  AddHostToList(const char *serverKey, nsIImapIncomingServer *server) = 0;
+  NS_IMETHOD ResetAll() = 0;
+
+  // Capabilities
+  NS_IMETHOD  GetHostHasAdminURL(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetHostHasAdminURL(const char *serverKey, bool hasAdminUrl) = 0;
+  // Subscription
+  NS_IMETHOD  GetHostIsUsingSubscription(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetHostIsUsingSubscription(const char *serverKey, bool usingSubscription) = 0;
+
+  // Passwords
+  NS_IMETHOD  GetPasswordForHost(const char *serverKey, nsString &result) = 0;
+  NS_IMETHOD  SetPasswordForHost(const char *serverKey, const char *password) = 0;
+  NS_IMETHOD  GetPasswordVerifiedOnline(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetPasswordVerifiedOnline(const char *serverKey) = 0;
+
+  // OnlineDir
+  NS_IMETHOD GetOnlineDirForHost(const char *serverKey,
+                                 nsString &result) = 0;
+  NS_IMETHOD SetOnlineDirForHost(const char *serverKey,
+                                 const char *onlineDir) = 0;
+
+  // Delete is move to trash folder
+  NS_IMETHOD GetDeleteIsMoveToTrashForHost(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD SetDeleteIsMoveToTrashForHost(const char *serverKey, bool isMoveToTrash) = 0;
+  NS_IMETHOD GetShowDeletedMessagesForHost(const char *serverKey, bool &result) = 0;
+
+  NS_IMETHOD SetShowDeletedMessagesForHost(const char *serverKey, bool showDeletedMessages) = 0;
+
+  // Get namespaces
+  NS_IMETHOD GetGotNamespacesForHost(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD SetGotNamespacesForHost(const char *serverKey, bool gotNamespaces) = 0;
+
+  // Folders
+  NS_IMETHOD SetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool discovered) = 0;
+  NS_IMETHOD GetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool &result) = 0;
+
+  // Trash Folder
+  NS_IMETHOD SetOnlineTrashFolderExistsForHost(const char *serverKey, bool exists) = 0;
+  NS_IMETHOD GetOnlineTrashFolderExistsForHost(const char *serverKey, bool &result) = 0;
+  
+  // INBOX
+  NS_IMETHOD  GetOnlineInboxPathForHost(const char *serverKey, nsString &result) = 0;
+  NS_IMETHOD  GetShouldAlwaysListInboxForHost(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetShouldAlwaysListInboxForHost(const char *serverKey, bool shouldList) = 0;
+
+  // Namespaces
+  NS_IMETHOD  GetNamespaceForMailboxForHost(const char *serverKey, const char *mailbox_name, nsIMAPNamespace * & result) = 0;
+  NS_IMETHOD  SetNamespaceFromPrefForHost(const char *serverKey, const char *namespacePref, EIMAPNamespaceType type) = 0;
+  NS_IMETHOD  AddNewNamespaceForHost(const char *serverKey, nsIMAPNamespace *ns) = 0;
+  NS_IMETHOD  ClearServerAdvertisedNamespacesForHost(const char *serverKey) = 0;
+  NS_IMETHOD  ClearPrefsNamespacesForHost(const char *serverKey) = 0;
+  NS_IMETHOD  GetDefaultNamespaceOfTypeForHost(const char *serverKey, EIMAPNamespaceType type, nsIMAPNamespace * & result) = 0;
+  NS_IMETHOD  SetNamespacesOverridableForHost(const char *serverKey, bool overridable) = 0;
+  NS_IMETHOD  GetNamespacesOverridableForHost(const char *serverKey,bool &result) = 0;
+  NS_IMETHOD  GetNumberOfNamespacesForHost(const char *serverKey, uint32_t &result) = 0;
+  NS_IMETHOD  GetNamespaceNumberForHost(const char *serverKey, int32_t n, nsIMAPNamespace * &result) = 0;
+  // ### dmb hoo boy, how are we going to do this?
+  NS_IMETHOD  CommitNamespacesForHost(nsIImapIncomingServer *server) = 0;
+  NS_IMETHOD  FlushUncommittedNamespacesForHost(const char *serverKey, bool &result) = 0;
+  
+  // Hierarchy Delimiters
+  NS_IMETHOD  SetNamespaceHierarchyDelimiterFromMailboxForHost(const char *serverKey, const char *boxName, char delimiter) = 0;
+
+  // Message Body Shells
+  NS_IMETHOD  AddShellToCacheForHost(const char *serverKey, nsIMAPBodyShell *shell) = 0;
+  NS_IMETHOD  FindShellInCacheForHost(const char *serverKey, const char *mailboxName, const char *UID, IMAP_ContentModifiedType modType, nsIMAPBodyShell **result) = 0;
+  NS_IMETHOD  ClearShellCacheForHost(const char *serverKey) = 0;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsIImapHostSessionList,
+                              NS_IIMAPHOSTSESSIONLIST_IID)
+
+#endif
diff --git a/mailnews/imap/public/nsIImapFlagAndUidState.idl b/mailnews/imap/public/nsIImapFlagAndUidState.idl
new file mode 100644
index 000000000..4a7498b9b
--- /dev/null
+++ b/mailnews/imap/public/nsIImapFlagAndUidState.idl
@@ -0,0 +1,74 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+[scriptable, uuid(290412eb-5824-4087-8984-05450c9397be)]
+interface nsIImapFlagAndUidState : nsISupports
+{
+  readonly attribute long numberOfMessages;
+  readonly attribute long numberOfRecentMessages;
+
+  /**
+   * If a full update, the total number of deleted messages
+   * in the folder; if a partial update, the number of deleted
+   * messages in the partial update
+   **/
+  readonly attribute long numberOfDeletedMessages;
+
+  /**
+   * If this is true, instead of fetching 1:* (FLAGS), and putting all
+   * UIDs and flags in the array, we only fetched the uids and flags
+   * that changed since the last time we were selected on this folder.
+   * This means we have a sparse array, and should not assume missing
+   * UIDs have been deleted.
+   **/
+  readonly attribute boolean partialUIDFetch;
+
+  /**
+   * Set of flags the server supports storing per message. See nsImapCore.h
+   * for the set of flags.
+   */
+  readonly attribute unsigned short supportedUserFlags;
+
+  /**
+   * OR's the  passed in flags with the previous flags because we want to
+   * accumulate the FLAGS and PERMANENTFLAGS response.
+   *
+   * @param aFlags - flags to OR with current flags.
+   */
+  void orSupportedUserFlags(in unsigned short aFlags);
+
+  void getUidOfMessage(in long zeroBasedIndex, out unsigned long result);
+  void getMessageFlags(in long zeroBasedIndex, out unsigned short result);
+  void setMessageFlags(in long zeroBasedIndex, in unsigned short flags);
+  void expungeByIndex(in unsigned long zeroBasedIndex);
+  void addUidFlagPair(in unsigned long uid, in unsigned short flags, in unsigned long zeroBasedIndex);
+  void addUidCustomFlagPair(in unsigned long uid, in string customFlag);
+  string getCustomFlags(in unsigned long uid); // returns space-separated keywords
+  void reset();
+  void clearCustomFlags(in unsigned long uid);
+  /**
+   * Adds custom attributes to a hash table for the purpose of storing them
+   * them.
+   * @param aUid   UID of the associated msg
+   * @param aCustomAttributeName   Name of the custom attribute value
+   * @param aCustomAttributeValue   Value of the attribute,
+   */
+  void setCustomAttribute(in unsigned long aUid,
+                          in ACString aCustomAttributeName,
+                          in ACString aCustomAttributeValue);
+
+  /**
+   * Gets the custom attributes from the hash table where they were stored earlier
+   * them.
+   * @param aUid   UID of the associated msg
+   * @param aCustomAttributeName   Name of the custom attribute value
+   * @param aCustomAttributeValue   Value of the attribute,
+   */
+  ACString getCustomAttribute(in unsigned long aUid,
+                              in ACString aCustomAttributeName);
+};
+
diff --git a/mailnews/imap/public/nsIImapHeaderXferInfo.idl b/mailnews/imap/public/nsIImapHeaderXferInfo.idl
new file mode 100644
index 000000000..b2b2e7840
--- /dev/null
+++ b/mailnews/imap/public/nsIImapHeaderXferInfo.idl
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+
+[scriptable, uuid(38f8f784-b092-11d6-ba4b-00108335942a)]
+interface nsIImapHeaderInfo : nsISupports {
+    attribute nsMsgKey  msgUid;
+    attribute long      msgSize;
+    [noscript] void getMsgHdrs ([shared] out string aMsgHdrs); // this doesn't copy the msgHdrs
+    void cacheLine(in string line, in unsigned long uid);
+    void resetCache();
+};
+
+[scriptable, uuid(f0842eda-af29-4ecd-82e1-fba91bd65d66)]
+interface nsIImapHeaderXferInfo : nsISupports {
+  readonly attribute long numHeaders;
+  nsIImapHeaderInfo  getHeader(in long hdrIndex);
+};
+
diff --git a/mailnews/imap/public/nsIImapIncomingServer.idl b/mailnews/imap/public/nsIImapIncomingServer.idl
new file mode 100644
index 000000000..2c687e0f3
--- /dev/null
+++ b/mailnews/imap/public/nsIImapIncomingServer.idl
@@ -0,0 +1,105 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsIImapUrl;
+interface nsIImapProtocol;
+interface nsIMsgFolder;
+interface nsIMsgWindow;
+
+typedef long nsMsgImapDeleteModel;
+
+[scriptable, uuid(bbfc33de-fe89-11d3-a564-0060b0fc04b7)]
+interface nsMsgImapDeleteModels
+{
+  const long IMAPDelete = 0;    /* delete with a big red x */
+  const long MoveToTrash = 1;   /* delete moves message to the trash */
+  const long DeleteNoTrash = 2; /* delete is shift delete - don't create or use trash */
+};
+
+[scriptable, uuid(ea6a0765-07b8-40df-924c-9004ed707251)]
+interface nsIImapIncomingServer : nsISupports {
+
+  attribute long maximumConnectionsNumber;
+  attribute ACString forceSelect;
+  attribute long timeOutLimits;
+  attribute ACString adminUrl;
+  attribute ACString serverDirectory;
+  /// RFC 2971 ID response stored as a pref
+  attribute ACString serverIDPref;
+  attribute boolean cleanupInboxOnExit;
+  attribute nsMsgImapDeleteModel deleteModel;
+  attribute boolean dualUseFolders;
+  attribute long emptyTrashThreshhold;
+  attribute ACString personalNamespace;
+  attribute ACString publicNamespace;
+  attribute ACString otherUsersNamespace;
+  attribute boolean offlineDownload;
+  attribute boolean overrideNamespaces;
+  attribute boolean usingSubscription;
+  attribute ACString manageMailAccountUrl;
+  attribute boolean fetchByChunks;
+  attribute boolean mimePartsOnDemand;
+  attribute boolean sendID;
+  attribute boolean isAOLServer;
+  attribute boolean capabilityACL;
+  attribute boolean capabilityQuota;
+  attribute boolean useIdle;
+  attribute boolean checkAllFoldersForNew;
+
+  /// Is this a GMail Server?
+  attribute boolean isGMailServer;
+
+  /**
+   * See IMAP RFC 4551
+   **/
+  attribute boolean useCondStore;
+
+  /**
+   * See IMAP RFC 4978
+   */
+  attribute boolean useCompressDeflate;
+
+  attribute AString trashFolderName;
+
+  attribute boolean downloadBodiesOnGetNewMail;
+  attribute boolean autoSyncOfflineStores;
+
+  /// Max age of messages we will autosync to, or keep in offline store.
+  attribute long autoSyncMaxAgeDays;
+
+  void GetImapConnectionAndLoadUrl(in nsIImapUrl aImapUrl,
+                                   in nsISupports aConsumer);
+
+  void RemoveConnection(in nsIImapProtocol aImapConnection);
+  void ResetNamespaceReferences();
+  void pseudoInterruptMsgLoad(in nsIMsgFolder aImapFolder, in nsIMsgWindow aMsgWindow, out boolean interrupted);
+  void ResetConnection(in ACString folderName);
+  void CloseConnectionForFolder(in nsIMsgFolder aMsgFolder);
+  void reDiscoverAllFolders();
+  nsIURI subscribeToFolder(in AString name, in boolean subscribe);
+  void GetNewMessagesForNonInboxFolders(in nsIMsgFolder aRootFolder,
+                                        in nsIMsgWindow aWindow,
+                                        in boolean forceAllFolders,
+                                        in boolean performingBiff);
+  /**
+   * Get the password from the nsIMsgIncomingServer. May prompt the user
+   * if there's no password in the password manager or cached in the 
+   * server object.
+   * @param aWindow  msgWindow to associate the password prompt with
+   * @return Password string.
+   * @exception NS_ERROR_FAILURE  The password could not be obtained.
+   * @note NS_MSG_PASSWORD_PROMPT_CANCELLED is a success code that is returned
+   *       if the prompt was presented to the user but the user cancelled the
+   *       prompt.
+   */
+  ACString PromptPassword(in nsIMsgWindow aWindow);
+  attribute boolean doingLsub;
+
+  ACString getUriWithNamespacePrefixIfNecessary(in long namespaceType, in ACString originalUri);
+  attribute boolean shuttingDown;
+};
diff --git a/mailnews/imap/public/nsIImapMailFolderSink.idl b/mailnews/imap/public/nsIImapMailFolderSink.idl
new file mode 100644
index 000000000..465e72b1d
--- /dev/null
+++ b/mailnews/imap/public/nsIImapMailFolderSink.idl
@@ -0,0 +1,103 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+
+#include "nsIImapProtocol.idl"
+#include "nsIMailboxSpec.idl"
+
+interface nsIMsgMailNewsUrl;
+interface nsIImapMockChannel;
+interface nsIImapHeaderXferInfo;
+
+typedef long ImapOnlineCopyState;
+
+[scriptable, uuid(5f7484b0-68b4-11d3-a53e-0060b0fc04b7)]
+interface ImapOnlineCopyStateType
+{
+   const long kInProgress = 0;
+   const long kSuccessfulCopy = 1;
+   const long kSuccessfulMove = 2;
+   const long kSuccessfulDelete = 3;
+   const long kFailedDelete = 4;
+   const long kReadyForAppendData = 5;
+   const long kFailedAppend = 6;
+   const long kInterruptedState = 7;
+   const long kFailedCopy = 8;
+   const long kFailedMove = 9;
+};
+
+[scriptable, uuid(525e1278-a39d-46d6-9dbc-b48c7e1d4faa)]
+interface nsIImapMailFolderSink : nsISupports {
+  attribute boolean folderNeedsACLListed;
+  attribute boolean folderNeedsSubscribing;
+  attribute boolean folderNeedsAdded;
+  attribute unsigned long aclFlags;
+  attribute long uidValidity;
+  /**
+   * Whether we have asked the server for this folder's quota information.
+   * If the server supports quotas, this occurs when the folder is opened.
+   */
+  attribute boolean folderQuotaCommandIssued;
+
+  /**
+   * Set FolderQuotaData information
+   * @param aFolderQuotaRoot    The IMAP quota root for this folder, 
+   *                            as returned by the GETQUOTAROOT IMAP command.
+   * @param aFolderQuotaUsedKB  Used space, in KB, on this folder's quota root.
+   * @param aFolderQuotaMaxKB   Size, in KB, of this folder's quota root.
+   **/
+  void setFolderQuotaData(in ACString aFolderQuotaRoot, in unsigned long aFolderQuotaUsedKB, 
+                          in unsigned long aFolderQuotaMaxKB);
+
+  /// Should we download all the rfc822 headers of messages, instead of subset.
+  readonly attribute boolean shouldDownloadAllHeaders;
+  readonly attribute char onlineDelimiter;
+  void OnNewIdleMessages();
+  // Tell mail master about the newly selected mailbox
+  void UpdateImapMailboxInfo(in nsIImapProtocol aProtocol,
+                             in nsIMailboxSpec aSpec);
+  void UpdateImapMailboxStatus(in nsIImapProtocol aProtocol,
+                               in nsIMailboxSpec aSpec);
+  /**
+   * Used when downloading headers in chunks.
+   * @param aSpec Mailbox spec of folder we're downloading headers for.
+   * @returns true if more to download, false otherwise.
+   * @returns total count of headers to download (across all chunks)
+   * @returns an array of msg keys to download, array size is this chunk's size
+   */
+  void getMsgHdrsToDownload(out boolean aMore, out long aTotalCount,
+                            out unsigned long aCount,
+                            [retval, array, size_is(aCount)] out nsMsgKey aKeys);
+  void parseMsgHdrs(in nsIImapProtocol aProtocol, in nsIImapHeaderXferInfo aHdrXferInfo);
+  void AbortHeaderParseStream(in nsIImapProtocol aProtocol) ;
+  
+  void OnlineCopyCompleted(in nsIImapProtocol aProtocol, in ImapOnlineCopyState aCopyState);
+  void StartMessage(in nsIMsgMailNewsUrl aUrl);
+  void EndMessage(in nsIMsgMailNewsUrl aUrl, in nsMsgKey uidOfMessage);
+
+  void NotifySearchHit(in nsIMsgMailNewsUrl aUrl, in string hitLine);
+
+  void copyNextStreamMessage(in boolean copySucceeded, in nsISupports copyState);
+  void closeMockChannel(in nsIImapMockChannel aChannel);
+  void setUrlState(in nsIImapProtocol aProtocol, in nsIMsgMailNewsUrl aUrl,
+                   in boolean isRunning, in boolean aSuspend,
+                   in nsresult status);
+  void releaseUrlCacheEntry(in nsIMsgMailNewsUrl aUrl);
+
+  void headerFetchCompleted(in nsIImapProtocol aProtocol);
+  void setBiffStateAndUpdate(in long biffState);
+  void progressStatusString(in nsIImapProtocol aProtocol, in string aMsgId, in wstring extraInfo);
+  void percentProgress(in nsIImapProtocol aProtocol, in wstring aMessage, 
+                       in long long aCurrentProgress, in long long aMaxProgressProgressInfo);
+
+  void clearFolderRights();
+  void setCopyResponseUid(in string msgIdString,
+                                in nsIImapUrl aUrl);
+  void setAppendMsgUid(in nsMsgKey newKey,
+                             in nsIImapUrl aUrl);
+  ACString getMessageId(in nsIImapUrl aUrl);
+};
diff --git a/mailnews/imap/public/nsIImapMessageSink.idl b/mailnews/imap/public/nsIImapMessageSink.idl
new file mode 100644
index 000000000..420ea7642
--- /dev/null
+++ b/mailnews/imap/public/nsIImapMessageSink.idl
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+#include "nsIImapUrl.idl"
+
+interface nsIMsgMailNewsUrl;
+
+[scriptable, uuid(6ffb6a92-e43a-405f-92ea-92cf81a5e17b)]
+
+interface nsIImapMessageSink : nsISupports {
+  // set up messge download output stream
+  void setupMsgWriteStream(in nsIFile aFile, in boolean aAppendDummyEnvelope);
+
+  /**
+   * Used by the imap protocol code to notify the core backend code about
+   * downloaded imap messages.
+   *
+   * @param aAdoptedMsgLine  a string with a lot of message lines,
+   *                         separated by native line terminators.
+   * @param aUidOfMsg        IMAP UID of the fetched message.
+   * @param aImapUrl         IMAP Url used to fetch the message.
+   */
+  void parseAdoptedMsgLine(in string aAdoptedMsgLine, in nsMsgKey aUidOfMsg,
+                           in nsIImapUrl aImapUrl);
+
+  /**
+   * Notify the backend that the imap protocol is done downloading a message
+   *
+   * @param aUidOfMsg           IMAP UID of the fetched message.
+   * @param aMarkMsgRead        Set the SEEN flag on the message.
+   * @param aImapUrl            IMAP Url used to fetch the message.
+   * @param aUpdatedMessageSize if this parameter is not -1, the stored size of the message
+   *                            should be set to this value to reflect the actual size of
+   *                            the downloaded message.
+   */
+  void normalEndMsgWriteStream(in nsMsgKey aUidOfMessage,
+                               in boolean aMarkMsgRead, in nsIImapUrl aImapUrl,
+                               in long aUpdatedMessageSize);
+
+  void abortMsgWriteStream();
+
+  void beginMessageUpload();
+
+  /**
+   *  Notify the message sink that one or more flags have changed
+   *  For Condstore servers, also update the highestMod Sequence
+   *  @param   aFlags         - The new flags for the message
+   *  @param   aKeywords        keywords for the message
+   *  @param   aMessageKey    - The UID of the message that changed
+   *  @param   aHighestModSeq - The highest mod seq the parser has seen
+   *                            for this folder
+  **/
+  void notifyMessageFlags(in unsigned long aFlags, in ACString aKeywords,
+                          in nsMsgKey aMessageKey,
+                          in unsigned long long aHighestModSeq);
+
+  void notifyMessageDeleted(in string aOnlineFolderName,in boolean aDeleteAllMsgs,in string aMsgIdString);
+
+  void getMessageSizeFromDB(in string aId, out unsigned long aSize);
+
+  void setContentModified(in nsIImapUrl aImapUrl, in nsImapContentModifiedType aModified);
+  
+  /**
+   * For a message stored in a file, get the message metadata needed to copy
+   * that message to an imap folder
+   *
+   * @param aRunningUrl  message URL
+   * @param aDate        message date
+   * @param aKeywords    message custom keywords (if supported by the server),
+   *                     including messages tags and junk status
+   *
+   * @return             message flags
+   */
+  unsigned long getCurMoveCopyMessageInfo(in nsIImapUrl aRunningUrl, 
+                                          out PRTime aDate, out ACString aKeywords);
+};
diff --git a/mailnews/imap/public/nsIImapMockChannel.idl b/mailnews/imap/public/nsIImapMockChannel.idl
new file mode 100644
index 000000000..ab4e6b996
--- /dev/null
+++ b/mailnews/imap/public/nsIImapMockChannel.idl
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+/*
+    Because imap protocol connections (which are channels) run through a cache,
+    it isn't always the case that when you want to run a url, you actually get
+    a connection back right away. Often times, the url goes into a queue until
+    a connection becomes available.
+
+    Unfortunately, if we want to be a truly pluggable protocol with necko, necko
+    requires the ability to get a channel back right away when it wants to run 
+    a url. It doesn't let you wait until an imap connection becomes available.
+
+    So I've created the notion of a "mock channel". This mock channel is what
+    gets returned to necko (or other callers) when they ask the imap service
+    for a new channel for a url. The mock channel has "mock" implementations
+    of nsIChannel. Eventually, when we actually assign the url to a real
+    channel, we set the real channel on the mock channel. From that point forward,
+    the mock channel forwards channel calls directly to the real channel.
+
+    In short, this class is how I'm solving the problem where necko wants
+    a channel back as soon as they ask for when with the fact that it
+    may be a while until the url is loaded into a connection.
+ */
+
+#include "nsISupports.idl"
+#include "nsIChannel.idl"
+
+interface nsIStreamListener;
+interface nsIProgressEventSink;
+interface nsIURI;
+interface nsIImapProtocol;
+
+[scriptable, uuid(e0178cd5-d37b-4bde-9ab8-752083536225)]
+
+interface nsIImapMockChannel : nsIChannel
+{
+  attribute nsIProgressEventSink progressEventSink;
+  void GetChannelListener(out nsIStreamListener aChannelListener);
+  void GetChannelContext(out nsISupports aChannelContext);
+  void Close();
+  void setImapProtocol(in nsIImapProtocol aProtocol);
+  [noscript] void setSecurityInfo(in nsISupports securityInfo);
+
+  void setURI(in nsIURI uri);
+};
diff --git a/mailnews/imap/public/nsIImapProtocol.idl b/mailnews/imap/public/nsIImapProtocol.idl
new file mode 100644
index 000000000..83b19a499
--- /dev/null
+++ b/mailnews/imap/public/nsIImapProtocol.idl
@@ -0,0 +1,71 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsIImapUrl;
+interface nsIImapProtocol;
+interface nsIImapIncomingServer;
+interface nsIMsgFolder;
+interface nsIImapHostSessionList;
+interface nsIMsgWindow;
+interface nsIImapFlagAndUidState;
+
+[scriptable, uuid(290412eb-5824-4087-8984-05450c9397be)]
+interface nsIImapProtocol : nsISupports {
+  void LoadImapUrl(in nsIURI aUrl, in nsISupports aConsumer);
+
+  /**
+   * IsBusy returns true if the connection is currently processing a url
+   * and false otherwise.
+   */
+  void IsBusy(out boolean aIsConnectionBusy,
+              out boolean isInboxConnection);
+
+  /** Protocol instance examines the url, looking at the host name,
+   * user name and folder the action would be on in order to figure out
+   * if it can process this url. I decided to push the semantics about
+   * whether a connection can handle a url down into the connection level
+   * instead of in the connection cache.
+   */
+  void CanHandleUrl(in nsIImapUrl aImapUrl, out boolean aCanRunUrl,
+                    out boolean hasToWait);
+
+  /**
+   * Initialize a protocol object.
+   * @param aHostSessionList host session list service
+   * @param aServer imap server the protocol object will be talking to
+   */
+  void Initialize(in nsIImapHostSessionList aHostSessionList, in nsIImapIncomingServer aServer);
+
+  void NotifyBodysToDownload(out unsigned long keys, in unsigned long count);
+  // methods to get data from the imap parser flag state.
+  void GetFlagsForUID(in unsigned long uid, out boolean foundIt, out unsigned short flags, out string customFlags);
+  void GetSupportedUserFlags(out unsigned short flags);
+
+  void GetRunningImapURL(out nsIImapUrl aImapUrl);
+
+  void GetRunningUrl(out nsIURI aUrl);
+
+  readonly attribute nsIImapFlagAndUidState flagAndUidState;
+  /**
+   * Tell thread to die - only call from the UI thread
+   *
+   * @param aIsSafeToClose false if we're dropping a timed out connection.
+   */
+  void tellThreadToDie(in boolean aIsSafeToClose);
+
+  // Get last active time stamp
+  void GetLastActiveTimeStamp(out PRTime aTimeStamp);
+
+  void pseudoInterruptMsgLoad(in nsIMsgFolder imapFolder, in nsIMsgWindow aMsgWindow, out boolean interrupted);
+  void GetSelectedMailboxName(out string folderName);
+  // Reset folder connection to authenticated state
+  void ResetToAuthenticatedState();
+
+  void OverrideConnectionInfo(in wstring pHost, in unsigned short pPort, in string pCookieData);
+};
+
diff --git a/mailnews/imap/public/nsIImapProtocolSink.idl b/mailnews/imap/public/nsIImapProtocolSink.idl
new file mode 100644
index 000000000..07b533065
--- /dev/null
+++ b/mailnews/imap/public/nsIImapProtocolSink.idl
@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+interface nsIMsgWindow;
+interface nsIMsgMailNewsUrl;
+
+/**
+ * Helper interface that contains operations MUST be proxied
+ * over UI thread.
+ */
+[scriptable, uuid(1217cd9d-7678-4026-b323-0d4b45816af0)]
+interface nsIImapProtocolSink : nsISupports {
+  
+  /**
+   * Does general cleanup for the imap protocol object.
+   */
+  void closeStreams();
+  /**
+   * Get the msg window associated with a url
+   *
+   * @param aUrl url whose msgWindow we want.
+   * @returns msgWindow associated with url.
+   */
+  nsIMsgWindow getUrlWindow(in nsIMsgMailNewsUrl aUrl);
+
+  /**
+   * Setup main thread proxies.
+   */
+  void setupMainThreadProxies();
+};
diff --git a/mailnews/imap/public/nsIImapServerSink.idl b/mailnews/imap/public/nsIImapServerSink.idl
new file mode 100644
index 000000000..77fdcb2d9
--- /dev/null
+++ b/mailnews/imap/public/nsIImapServerSink.idl
@@ -0,0 +1,169 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+
+interface nsIMsgWindow;
+interface nsIMsgMailNewsUrl;
+interface nsIImapProtocol;
+interface nsIImapUrl;
+interface nsIImapMockChannel;
+
+/**
+ * nsIImapServerSink is designed to be used as a proxy to the application's UI
+ * thread from the running IMAP threads.
+ */
+[scriptable, uuid(2160c641-e4fa-4bbc-ab8b-d9ba45069027)]
+interface nsIImapServerSink : nsISupports {
+  /**
+   * Check if the given folder path is a possible IMAP mailbox.
+   * @param folderPath folder path to check
+   * @param hierarchyDelimiter IMAP hierarchy delimiter in canonical format,
+   *                           i.e., hierarchy delimiter has been replaced
+   *                           with '/'
+   * @param boxFlags IMAP folder flags (for subscription, namespaces etc.)
+   * @return true if it's a new mailbox
+   */
+  boolean possibleImapMailbox(in ACString folderPath,
+                              in char hierarchyDelimiter, in long boxFlags);
+  boolean folderNeedsACLInitialized(in ACString folderPath);
+  void addFolderRights(in ACString folderPath, in ACString userName, in ACString rights);
+  void refreshFolderRights(in ACString folderPath);
+  void discoveryDone();
+  void onlineFolderDelete(in ACString folderName);
+  void onlineFolderCreateFailed(in ACString aFolderName);
+  void onlineFolderRename(in nsIMsgWindow msgWindow, in ACString oldName, in ACString newName);
+  boolean folderIsNoSelect(in ACString folderName);
+  void setFolderAdminURL(in ACString folderName, in ACString adminUrl);
+  boolean folderVerifiedOnline(in ACString folderName);
+
+  void setCapability(in unsigned long long capability);
+  /// RFC 2971 ID server response
+  void setServerID(in ACString aServerID);
+  boolean loadNextQueuedUrl(in nsIImapProtocol protocol);
+
+  /**
+   * Prepare to retry the given URL.
+   * @param imapUrl the url we're going to retry
+   * @return channel to associate with the url. We return this because access
+   *         to the channel should only happen on the ui thread.
+   */
+  nsIImapMockChannel prepareToRetryUrl(in nsIImapUrl imapUrl);
+
+  /**
+   * Suspend the url. This puts it at the end of the queue. If the queue is
+   * empty, the url will get resumed immediately. Currently, the plan is
+   * do this when we have to download a lot of headers in chunks, though we
+   * could find other uses for it.
+   * @param imapUrl url to suspend
+   */
+  void suspendUrl(in nsIImapUrl aImapUrl);
+
+  /**
+   * Retry the given URL.
+   * @param imapUrl url to retry
+   * @param channel the channel to associate with the url
+   */
+  void retryUrl(in nsIImapUrl imapUrl, in nsIImapMockChannel channel);
+
+  /**
+   * If previous URL failed, this gives server chance to abort URLs with same
+   * mock channel.
+   */
+  void abortQueuedUrls();
+  AString getImapStringByName(in string msgName);
+  /**
+   * Alerts the user that the login to the IMAP server failed. Asks whether the
+   * connection should: retry, cancel, or request a new password.
+   *
+   * @param aMsgWindow The message window associated with this action (cannot
+   *                   be null).
+   * @return           The button pressed. 0 for retry, 1 for cancel,
+   *                   2 for enter a new password.
+   */
+  int32_t promptLoginFailed(in nsIMsgWindow aMsgWindow);
+
+  /**
+   * Alerts the user with the given string (FE = 'Front End').
+   *
+   * @param aAlertString The string to alert the user with.
+   * @param aUrl         The running url.
+   */
+  void fEAlert(in AString aAlertString, in nsIMsgMailNewsUrl aUrl);
+
+  /**
+   * Alerts the user with a localized string. It will attempt to fill in
+   * the hostname into the string if necessary.
+   *
+   * @param aMsgName  The id of the string to present to the user..
+   * @param aUrl    The running url.
+   */
+  void fEAlertWithName(in string aMsgName, in nsIMsgMailNewsUrl aUrl);
+  /**
+   * Takes a response from the server and prepends it with IMAP_SERVER_SAID 
+   *
+   * @param aServerString  The string to alert the user with.
+   * @param url            The running url.
+   */
+  void fEAlertFromServer(in ACString aServerString, in nsIMsgMailNewsUrl aUrl);
+
+  void commitNamespaces();
+
+  /**
+   * Returns a password via the out param, if we were able to prompt for one,
+   * or had one stored.
+   * If there is already a password prompt up, we return false, but we
+   * ask the async prompt service to notify us when we can put up a prompt.
+   * When that notification is received, we prompt the user and set the
+   * password on the protocol object, and signal a monitor that the imap
+   * thread should be waiting on.
+   *
+   * rv is NS_MSG_PASSWORD_PROMPT_CANCELLED if the user cancels the
+   * password prompt. That's not an exception, however.
+   *
+   * @param aProtocol imap protocol object requesting the password.
+   * @param aNewPasswordRequested Forces password prompt immediately
+   * @param aPassword returns the password, unless we had to prompt or use the,
+   *                  login manager and there was already a prompt up.
+   */
+  void asyncGetPassword(in nsIImapProtocol aProtocol,
+                        in boolean aNewPasswordRequested,
+                        out ACString aPassword);
+
+  attribute boolean userAuthenticated;
+  void setMailServerUrls(in ACString manageMailAccount, in ACString manageLists, in ACString manageFilters);
+
+  /** Used by the imap thread when upgrading from the socketType
+   * trySTARTTLS.
+   * @param aSucceeded whether STARTTLS succeeded. If it did, the server
+   * will set the socket type to alwaysSTARTTLS, otherwise plain.
+   */
+  void UpdateTrySTARTTLSPref(in boolean aSucceeded);
+
+  readonly attribute ACString arbitraryHeaders;
+  void forgetPassword();
+
+  readonly attribute boolean showAttachmentsInline;
+  string cramMD5Hash(in string decodedChallenge, in string key);
+  /// String to send to the imap server as the login user name.
+  readonly attribute ACString loginUsername;
+  /// String to send to the imap server as the user name.
+  readonly attribute ACString originalUsername;
+  /// Internal pref key, unique over all servers
+  readonly attribute ACString serverKey;
+  /// password for server login
+  readonly attribute ACString serverPassword;
+  /// remove a connection to the server
+  void removeServerConnection(in nsIImapProtocol aProtocol);
+  /// is the imap server shutting down?
+  readonly attribute boolean serverShuttingDown;
+  /// reset the connection for a particular folder
+  void resetServerConnection(in ACString aFolderName);
+  /// tell the server if listing using lsub command
+  void setServerDoingLsub(in boolean aDoingLsub);
+  /// set force select string
+  void SetServerForceSelect(in ACString forceSelect);
+};
diff --git a/mailnews/imap/public/nsIImapService.idl b/mailnews/imap/public/nsIImapService.idl
new file mode 100644
index 000000000..0a8521ee6
--- /dev/null
+++ b/mailnews/imap/public/nsIImapService.idl
@@ -0,0 +1,258 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The IMAP Service is an interfaced designed to make building and running imap urls
+// easier. Clients typically go to the imap service and ask it do things such as:
+// get new mail, etc....
+//
+// Oh and in case you couldn't tell by the name, the imap service is a service! and you
+// should go through the service manager to obtain an instance of it.
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include "nsISupports.idl"
+#include "nsIImapUrl.idl"
+
+interface nsIImapMessageSink;
+interface nsIUrlListener;
+interface nsIURI;
+interface nsIFile;
+interface nsIMsgFolder;
+interface nsIMsgWindow;
+interface nsIImapIncomingServer;
+interface nsICacheStorage;
+
+[scriptable, uuid(aba44b3d-7a0f-4987-8794-96d2de66d966)]
+interface nsIImapService : nsISupports
+{
+  // You can pass in null for the url listener and the url if you don't require either.....
+  void selectFolder(in nsIMsgFolder aImapMailFolder,
+                    in nsIUrlListener aUrlListener,
+                    in nsIMsgWindow   aMsgWindow,
+                    out nsIURI aURL);
+
+  /**
+   * Select the folder on the imap server without doing a sync of flags or
+   * headers. This is used for offline playback, where we don't want to
+   * download hdrs we don't have, because they may have been offline deleted.
+   *
+   * @param aImapMailFolder     the folder to select
+   * @param aUrlListener        url listener, can be null
+   * @param aMsgWindow          msg window url is running in, can be null
+   *
+   * @returns the url created to run the lite select in.
+   */
+  nsIURI liteSelectFolder(in nsIMsgFolder aImapMailFolder,
+                          in nsIUrlListener aUrlListener,
+                          in nsIMsgWindow aMsgWindow);
+
+  void addImapFetchToUrl(in nsIURI aURL,
+                         in nsIMsgFolder aImapMailFolder,
+                         in ACString aMessageIdentifierList,
+                         in ACString aAdditionalHeader);
+
+  void fetchMessage(in nsIImapUrl aUrl,
+                    in nsImapState aImapAction,
+                    in nsIMsgFolder aImapMailFolder,
+                    in nsIImapMessageSink aImapMessageSink,
+                    in nsIMsgWindow aMsgWindow,
+                    in nsISupports aConsumer,
+                    in ACString aMessageIdentifierList,
+                    in boolean convertDataToText,
+                    in ACString additionalHeader,
+                    out nsIURI aOutURL);
+
+  void noop(in nsIMsgFolder aImapMailFolder,
+            in nsIUrlListener aUrlListener,
+            out nsIURI aURL);
+
+  void getHeaders(in nsIMsgFolder aImapMailFolder,
+                  in nsIUrlListener aUrlListener,
+                  out nsIURI aURL,
+                  in ACString aMessageIdentifierList,
+                  in boolean aMessageIdsAreUID);
+
+  nsIURI getBodyStart(in nsIMsgFolder aImapMailFolder,
+                      in nsIUrlListener aUrlListener,
+                      in ACString aMessageIdentifierList,
+                      in long numBytes);
+
+  /**
+   * Issue an EXPUNGE on the target folder.
+   *
+   * @param aImapMailFolder     the folder to expunge
+   * @param aUrlListener        url listener, can be null
+   * @param aMsgWindow          msg window url is running in, can be null
+   *
+   * @returns the url created to run the expunge.
+   */
+  void expunge(in nsIMsgFolder aImapMailFolder,
+               in nsIUrlListener aUrlListener,
+               in nsIMsgWindow aMsgWindow,
+               out nsIURI aURL);
+
+  /**
+   * Issue a STATUS on the target folder.
+   *
+   * @param aImapMailFolder     the folder to expunge
+   * @param aUrlListener        url listener, can be null
+   *
+   * @returns the url created to run the status.
+   */
+  nsIURI updateFolderStatus(in nsIMsgFolder aImapMailFolder,
+                            in nsIUrlListener aUrlListener);
+
+  /**
+   * Verify that we can login.
+   *
+   * @param aImapMailFolder - any old imap folder - we just need it to
+   *                          set url sinks.
+   * @param aMsgWindow    - nsIMsgWindow to use for notification callbacks.
+   * @return - the url that we run.
+   */
+  nsIURI verifyLogon(in nsIMsgFolder aImapMailFolder,
+                     in nsIUrlListener aUrlListener,
+                     in nsIMsgWindow aMsgWindow);
+
+  void biff(in nsIMsgFolder aImapMailFolder,
+            in nsIUrlListener aUrlListener,
+            out nsIURI aURL,
+            in unsigned long aUidHighWater);
+
+  void deleteMessages(in nsIMsgFolder aImapMailFolder,
+                      in nsIUrlListener aUrlListener,
+                      out nsIURI aURL,
+                      in ACString aMessageIdentifierList,
+                      in boolean aMessageIdsAreUID);
+
+  void deleteAllMessages(in nsIMsgFolder aImapMailFolder,
+                         in nsIUrlListener aUrlListener,
+                         out nsIURI aURL);
+
+  void addMessageFlags(in nsIMsgFolder aImapMailFolder,
+                       in nsIUrlListener aUrlListener,
+                       out nsIURI aURL,
+                       in ACString aMessageIdentifierList,
+                       in imapMessageFlagsType aFlags,
+                       in boolean aMessageIdsAreUID);
+
+  void subtractMessageFlags(in nsIMsgFolder aImapMailFolder,
+                            in nsIUrlListener aUrlListener,
+                            out nsIURI aURL,
+                            in ACString aMessageIdentifierList,
+                            in imapMessageFlagsType aFlags,
+                            in boolean aMessageIdsAreUID);
+
+  void setMessageFlags(in nsIMsgFolder aImapMailFolder,
+                       in nsIUrlListener aUrlListener,
+                       out nsIURI aURL,
+                       in ACString aMessageIdentifierList,
+                       in imapMessageFlagsType aFlags,
+                       in boolean aMessageIdsAreUID);
+
+  void discoverAllFolders(in nsIMsgFolder aImapMailFolder,
+                          in nsIUrlListener aUrlListener,
+                          in nsIMsgWindow aMsgWindow,
+                          out nsIURI aURL);
+
+  void discoverAllAndSubscribedFolders(in nsIMsgFolder aImapMailFolder,
+                                       in nsIUrlListener aUrlListener,
+                                       out nsIURI aURL);
+
+  void discoverChildren(in nsIMsgFolder aImapMailFolder,
+                        in nsIUrlListener aUrlListener,
+                        in ACString folderPath,
+                        out nsIURI aURL);
+
+  void onlineMessageCopy(in nsIMsgFolder aSrcFolder,
+                         in ACString aMessageIds,
+                         in nsIMsgFolder aDstFolder,
+                         in boolean aIdsAreUids,
+                         in boolean aIsMove,
+                         in nsIUrlListener aUrlListener,
+                         out nsIURI aURL,
+                         in nsISupports aCopyState,
+                         in nsIMsgWindow aWindow);
+
+
+  void appendMessageFromFile(in nsIFile aFile,
+                             in nsIMsgFolder aDstFolder,
+                             in ACString aMessageId,
+                             in boolean idsAreUids,
+                             in boolean aInSelectedState,
+                             in nsIUrlListener aUrlListener,
+                             out nsIURI aURL,
+                             in nsISupports aCopyState,
+                             in nsIMsgWindow aMsgWindow);
+
+  void downloadMessagesForOffline(in ACString aMessageIds, in nsIMsgFolder aSrcFolder,
+                      in nsIUrlListener aListener, in nsIMsgWindow   aMsgWindow);
+
+  nsIURI moveFolder(in nsIMsgFolder aSrcFolder,
+                    in nsIMsgFolder aDstFolder,
+                    in nsIUrlListener aUrlListener,
+                    in nsIMsgWindow msgWindow);
+
+  nsIURI renameLeaf(in nsIMsgFolder aSrcFolder,
+                    in AString aLeafName,
+                    in nsIUrlListener aUrlListener,
+                    in nsIMsgWindow msgWindow);
+
+  nsIURI deleteFolder(in nsIMsgFolder aFolder,
+                      in nsIUrlListener aUrlListener,
+                      in nsIMsgWindow aMsgWindow);
+
+  nsIURI createFolder(in nsIMsgFolder aParentFolder,
+                      in AString aLeafName,
+                      in nsIUrlListener aUrlListener);
+
+  nsIURI listFolder(in nsIMsgFolder aMailFolder,
+                    in nsIUrlListener aUrlListener);
+
+  nsIURI subscribeFolder(in nsIMsgFolder aMailFolder,
+                         in AString mailboxName,
+                         in nsIUrlListener aUrlListener);
+
+  nsIURI unsubscribeFolder(in nsIMsgFolder aMailFolder,
+                           in AString mailboxName,
+                           in nsIUrlListener aUrlListener);
+
+  // this method will first check if the folder exists but is
+  // not subscribed to, in which case it will subscribe to the folder.
+  // otherwise, it will try to create the folder. It will try to do this
+  // with one url.
+  nsIURI ensureFolderExists(in nsIMsgFolder aParentFolder,
+                            in AString aLeafName,
+                            in nsIUrlListener aUrlListener);
+
+
+  nsIURI getFolderAdminUrl(in nsIMsgFolder aMailFolder,
+                           in nsIMsgWindow   aMsgWindow,
+                           in nsIUrlListener aUrlListener);
+
+  nsIURI issueCommandOnMsgs(in nsIMsgFolder aMailFolder,
+                            in nsIMsgWindow aMsgWindow,
+                            in ACString aCommand,
+                            in ACString aMessageIdentifierList);
+
+  nsIURI fetchCustomMsgAttribute(in nsIMsgFolder aMailFolder,
+                                 in nsIMsgWindow aMsgWindow,
+                                 in ACString aAttribute,
+                                 in ACString aMessageIdentifierList);
+
+  nsIURI storeCustomKeywords(in nsIMsgFolder aMailFolder,
+                             in nsIMsgWindow aMsgWindow,
+                             in ACString flagsToAdd,
+                             in ACString flagsToSubtract,
+                             in ACString aMessageIdentifierList);
+
+  void getListOfFoldersOnServer(in nsIImapIncomingServer aServer, in nsIMsgWindow aMsgWindow);
+  void getListOfFoldersWithPath(in nsIImapIncomingServer aServer, in nsIMsgWindow aMsgWindow, in ACString folderPath);
+
+  nsISupports playbackAllOfflineOperations(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
+  void downloadAllOffineImapFolders(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
+
+  readonly attribute nsICacheStorage cacheStorage;
+};
diff --git a/mailnews/imap/public/nsIImapUrl.idl b/mailnews/imap/public/nsIImapUrl.idl
new file mode 100644
index 000000000..03d0e03e0
--- /dev/null
+++ b/mailnews/imap/public/nsIImapUrl.idl
@@ -0,0 +1,207 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIImapMailFolderSink;
+interface nsIImapMessageSink;
+interface nsIImapServerSink;
+interface nsIImapMockChannel;
+interface nsIFile;
+
+typedef long nsImapAction;
+typedef long nsImapState;
+
+typedef unsigned short imapMessageFlagsType;
+
+typedef long nsImapContentModifiedType;
+
+[scriptable, uuid(2e91901e-ff6c-11d3-b9fa-00108335942a)]
+interface nsImapContentModifiedTypes
+{
+  const long IMAP_CONTENT_NOT_MODIFIED = 0;
+  const long IMAP_CONTENT_MODIFIED_VIEW_INLINE = 1;
+  const long IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS = 2;
+  const long IMAP_CONTENT_FORCE_CONTENT_NOT_MODIFIED = 3;
+} ;
+
+[scriptable, uuid(fe2a8f9e-2886-4146-9896-27fff660c69f)]
+interface nsIImapUrl : nsISupports
+{
+  ///////////////////////////////////////////////////////////////////////////////
+  // Getters and Setters for the imap specific event sinks to bind to to the url
+  ///////////////////////////////////////////////////////////////////////////////
+  attribute nsIImapMailFolderSink imapMailFolderSink;
+  attribute nsIImapMessageSink imapMessageSink;
+  attribute nsIImapServerSink imapServerSink;
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Getters and Setters for the imap url state
+  ///////////////////////////////////////////////////////////////////////////////
+  attribute nsImapAction imapAction;
+  readonly attribute nsImapState requiredImapState;
+  readonly attribute string imapPartToFetch;
+  readonly attribute ACString customAttributeToFetch;
+  attribute ACString customAttributeResult;
+  readonly attribute ACString command;
+  attribute ACString customCommandResult;
+  readonly attribute ACString customAddFlags;
+  readonly attribute ACString customSubtractFlags;
+  void allocateCanonicalPath(in string aServerPath, in char aOnlineDelimiter, out string aAllocatedPath);
+  void allocateServerPath(in string aCanonicalPath, in char aOnlineDelimiter, out string aAllocatedPath);
+  string createServerSourceFolderPathString();
+  string createCanonicalSourceFolderPathString();
+  string createServerDestinationFolderPathString();
+
+  string addOnlineDirectoryIfNecessary(in string onlineMailboxName);
+  void createSearchCriteriaString (out string aResult);
+  readonly attribute ACString listOfMessageIds;
+
+  boolean messageIdsAreUids();
+  readonly attribute imapMessageFlagsType msgFlags; // kAddMsgFlags or kSubtractMsgFlags only
+
+  readonly attribute long numBytesToFetch;
+  attribute char onlineSubDirSeparator;
+  attribute boolean allowContentChange;
+  attribute boolean mimePartSelectorDetected;
+  attribute nsImapContentModifiedType contentModified;
+  attribute boolean fetchPartsOnDemand;  // set to true if we're fetching a msg for display and want to not download parts
+  attribute boolean msgLoadingFromCache; // true if this msg load is coming from a cache, so we can know to mark it read
+  attribute boolean externalLinkUrl; // true if we ran this url because the user clicked on a link.
+  attribute boolean validUrl; // false if we couldn't parse url for whatever reason.
+  attribute nsISupports copyState;
+  attribute nsIFile msgFile;
+  attribute nsIImapMockChannel mockChannel;
+  /**
+   * Set to true if we should store the msg(s) for offline use if we can,
+   * e.g., we're fetching a message and the folder is configured for offline
+   * use and we're not doing mime parts on demand.
+   */
+  attribute boolean storeResultsOffline;
+  /**
+   * If we fallback from fetching by parts to fetching the whole message,
+   *  because all the parts were inline, this tells us we should store
+   * the message offline.
+   */
+  attribute boolean storeOfflineOnFallback;
+
+  /**
+   * This attribute defaults to false, but if we only want to use the offline
+   * cache (disk, memory, or offline store) to fetch the message, then we set
+   * this to true. Currently, nsIMsgMessageService.streamMessage does this.
+   */
+  attribute boolean localFetchOnly;
+
+  /// Server disconnected first time so we're retrying.
+  attribute boolean rerunningUrl;
+
+  /**
+   * Do we have more headers to download? This is set when we decide to
+   * download newest headers first, followed by older headers in a subsequent
+   * run of the url, which allows other urls to run against the folder in the
+   * meantime.
+   */
+  attribute boolean moreHeadersToDownload;
+
+  /**
+   * @{
+   * This is used to tell the runner of the url more about the status of
+   * the command, beyond whether it was successful or not. For example,
+   * subtracting flags from a UID that doesn't exist isn't an error
+   * (the server returns OK), but the backend code may want to know about it.
+   */
+  attribute long extraStatus;
+
+  /**
+   * Current possible extra status values
+   */
+  const long ImapStatusNone = 0;
+  const long ImapStatusFlagChangeFailed = 1;
+  const long ImapStatusFlagsNotSettable = 2;
+  /** @} */
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Enumerated types specific to imap urls...
+  ///////////////////////////////////////////////////////////////////////////////
+
+  // the following are nsImapState enums.
+  // we have a basic set of imap url actions. These actions are nsImapActions.
+  // Certain actions require us to be in the authenticated state and others require us to
+  // be in the selected state. nsImapState is used to store the state the url needs to
+  // be in. You'll later see us refer to the imap url state in the imap protocol when we
+  // are processing the current url. Don't confuse nsImapState with the generic url state
+  // used to keep track of whether the url is running or not...
+  const long nsImapAuthenticatedState = 0;
+  const long nsImapSelectedState = 1;
+
+  const long nsImapActionSendText = 0;      // a state used for testing purposes to send raw url text straight to the server....
+  // nsImapAuthenticatedStateUrl urls
+  // since the following url actions require us to be in the authenticated
+  // state, the high bit is left blank....
+  const long nsImapTest  = 0x00000001;
+  const long nsImapCreateFolder  = 0x00000005;
+  const long nsImapDeleteFolder  = 0x00000006;
+  const long nsImapRenameFolder  = 0x00000007;
+  const long nsImapMoveFolderHierarchy = 0x00000008;
+  const long nsImapLsubFolders  = 0x00000009;
+  const long nsImapGetMailAccountUrl = 0x0000000A;
+  const long nsImapDiscoverChildrenUrl = 0x0000000B;
+  const long nsImapDiscoverAllBoxesUrl = 0x0000000D;
+  const long nsImapDiscoverAllAndSubscribedBoxesUrl  = 0x0000000E;
+  const long nsImapAppendMsgFromFile = 0x0000000F;
+  const long nsImapSubscribe = 0x00000010;
+  const long nsImapUnsubscribe = 0x00000011;
+  const long nsImapRefreshACL  = 0x00000012;
+  const long nsImapRefreshAllACLs  = 0x00000013;
+  const long nsImapListFolder  = 0x00000014;
+  const long nsImapUpgradeToSubscription = 0x00000015;
+  const long nsImapFolderStatus  = 0x00000016;
+  const long nsImapRefreshFolderUrls = 0x00000017;
+  const long nsImapEnsureExistsFolder = 0x00000018;
+  const long nsImapOfflineToOnlineCopy = 0x00000019;
+  const long nsImapOfflineToOnlineMove = 0x0000001A;
+  const long nsImapVerifylogon = 0x0000001B;
+  // it's okay to add more imap actions that require us to
+  // be in the authenticated state here without renumbering
+  // the imap selected state url actions. just make sure you don't
+  // set the high bit...
+
+  // nsImapSelectedState urls. Note, the high bit is always set for
+  // imap actions which require us to be in the selected state
+  const long nsImapSelectFolder  = 0x10000002;
+  const long nsImapLiteSelectFolder = 0x10000003;
+  const long nsImapExpungeFolder = 0x10000004;
+  const long nsImapMsgFetch  = 0x10000018;
+  const long nsImapMsgHeader = 0x10000019;
+  const long nsImapSearch  = 0x1000001A;
+  const long nsImapDeleteMsg = 0x1000001B;
+  const long nsImapDeleteAllMsgs = 0x1000001C;
+  const long nsImapAddMsgFlags = 0x1000001D;
+  const long nsImapSubtractMsgFlags  = 0x1000001E;
+  const long nsImapSetMsgFlags = 0x1000001F;
+  const long nsImapOnlineCopy  = 0x10000020;
+  const long nsImapOnlineMove  = 0x10000021;
+  const long nsImapOnlineToOfflineCopy = 0x10000022;
+  const long nsImapOnlineToOfflineMove = 0x10000023;
+  const long nsImapMsgPreview = 0x10000024;
+  const long nsImapBiff  = 0x10000026;
+  const long nsImapSelectNoopFolder  = 0x10000027;
+  const long nsImapAppendDraftFromFile = 0x10000028;
+  const long nsImapUidExpunge = 0x10000029;
+  const long nsImapSaveMessageToDisk = 0x10000030;
+  const long nsImapOpenMimePart = 0x10000031;
+  const long nsImapMsgDownloadForOffline  = 0x10000032;
+  const long nsImapDeleteFolderAndMsgs = 0x10000033;
+  const long nsImapUserDefinedMsgCommand = 0x10000034;
+  const long nsImapUserDefinedFetchAttribute = 0x10000035;
+  const long nsImapMsgFetchPeek = 0x10000036;
+  const long nsImapMsgStoreCustomKeywords = 0x10000037;
+
+  /// Constant for the default IMAP port number
+  const int32_t DEFAULT_IMAP_PORT = 143;
+
+  /// Constant for the default IMAP over ssl port number
+  const int32_t DEFAULT_IMAPS_PORT = 993;
+};
diff --git a/mailnews/imap/public/nsIMailboxSpec.idl b/mailnews/imap/public/nsIMailboxSpec.idl
new file mode 100644
index 000000000..5888ecbf3
--- /dev/null
+++ b/mailnews/imap/public/nsIMailboxSpec.idl
@@ -0,0 +1,43 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIImapFlagAndUidState.idl"
+
+interface nsIMAPNamespace;
+
+[scriptable, uuid(a9fbbc80-5291-4ed8-a7f7-c2fcad231269)]
+interface nsIMailboxSpec : nsISupports
+{
+  attribute long folder_UIDVALIDITY;
+  /**
+   * The highest modification sequence number the parser has seen 
+   * for this mailbox. See IMAP RFC 4551
+   **/
+  attribute unsigned long long highestModSeq;
+  attribute long numMessages;
+  attribute long numUnseenMessages;
+  attribute long numRecentMessages;
+
+  /// If server supports UIDNEXT, we store the result here.
+  attribute long nextUID;
+
+  attribute unsigned long box_flags;
+  attribute unsigned long supportedUserFlags;
+
+  attribute ACString allocatedPathName;
+  attribute AString unicharPathName;
+  attribute char hierarchyDelimiter;
+  attribute ACString hostName;
+
+  attribute nsIImapFlagAndUidState flagState;
+
+  attribute boolean folderSelected;
+  attribute boolean discoveredFromLsub;
+
+  attribute boolean onlineVerified;
+
+  [noscript] attribute nsIMAPNamespace  namespaceForFolder;
+};
diff --git a/mailnews/imap/public/nsIMsgImapMailFolder.idl b/mailnews/imap/public/nsIMsgImapMailFolder.idl
new file mode 100644
index 000000000..f86f622b4
--- /dev/null
+++ b/mailnews/imap/public/nsIMsgImapMailFolder.idl
@@ -0,0 +1,215 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIMsgFolder.idl"
+#include "nsIStringEnumerator.idl"
+
+interface nsIMsgWindow;
+interface nsIImapIncomingServer;
+interface nsIMsgParseMailMsgState;
+interface nsIAutoSyncState;
+
+/**
+ * This is a simple interface which allows the IMAP folder to update some
+ * values that the folder props js code will use to update the sharing and
+ * quota tabs in the folder properties.
+ */
+[scriptable, uuid(09D99F2C-3E23-4f8c-A536-5C277BAA9585)] 
+interface nsIMsgImapFolderProps : nsISupports {
+
+    void setFolderType(in AString folderType);
+    void setFolderTypeDescription(in AString folderTypeDescription);
+    void setFolderPermissions(in AString permissions);
+    void serverDoesntSupportACL();
+
+    /**
+     * Toggles the display of quota information in the Quota tab of the folder properties.
+     * If on, the quota root, usage, and percentage used are displayed.
+     * If off, a status message is displayed. The status message can be set with setQuotaStatus().
+     * @param showData If true, display the quota root, usage information and usage percentage bar.
+     *                 If false, display the status message.
+     */
+    void showQuotaData(in boolean showData);
+
+    /**
+     * Sets the status string displayed in the Quota tab of the folder properties if quota
+     * information is not visible.
+     */
+    void setQuotaStatus(in AString folderQuotaStatus);
+
+    /**
+     * Updates the quota data displayed in the Quota tab.
+     */
+    void setQuotaData(in ACString quotaroot, in unsigned long usedKB, in unsigned long maxKB);
+};
+
+[scriptable, uuid(fea0f455-7adf-4683-bf2f-c95c3fff03df)]
+interface nsIMsgImapMailFolder : nsISupports {
+  void removeSubFolder(in nsIMsgFolder folder);
+  void createClientSubfolderInfo(in ACString folderName, in char hierarchyDelimiter,
+                                 in long flags, in boolean suppressNotification);
+  void list();
+  void renameLocal(in ACString newname, in nsIMsgFolder parent);
+  void prepareToRename();
+  void performExpand(in nsIMsgWindow aMsgWindow);
+  void recursiveCloseActiveConnections(in nsIImapIncomingServer aImapServer);
+  void renameClient(in nsIMsgWindow msgWindow, in nsIMsgFolder msgFolder, in ACString oldName, in ACString newName);
+
+  // these are used for offline synchronization
+  void storeImapFlags(in long aFlags, in boolean aAddFlags, [array, size_is (aNumKeys)] 
+      in nsMsgKey aKeysToFlag, in unsigned long aNumKeys, in nsIUrlListener aUrlListener);
+  nsIURI setImapFlags(in string uids, in long flags);
+  void replayOfflineMoveCopy([array, size_is (numKeys)] in nsMsgKey keys, in unsigned long numKeys, in boolean isMove, in nsIMsgFolder aDstFolder,
+                         in nsIUrlListener aUrlListener, in nsIMsgWindow aWindow);
+  nsIURI playbackOfflineFolderCreate(in AString folderName, in nsIMsgWindow aWindow);
+  /**
+   * This is called by the offline sync code to tell the imap folder to
+   * remember info about the header with this key (messageId and key) because
+   * it's an offline move result header, and we need to generate an
+   * nsIMsgFolderListener.msgKeyChanged notification when we download the
+   * real header from the imap server.
+   *
+   * @param aMsgKey msg key of move result pseudo hdr.
+   */
+  void addMoveResultPseudoKey(in nsMsgKey aMsgKey);
+  /**
+   * Select this folder on the imap server without doing a sync of flags or
+   * headers. This is used for offline playback, where we don't want to
+   * download hdrs we don't have, because they may have been offline deleted.
+   *
+   * @param aUrlListener        url listener, can be null
+   * @param aWindow          msg window url is running in, can be null
+   */
+  void liteSelect(in nsIUrlListener aUrlListener, in nsIMsgWindow aWindow);
+
+  void fillInFolderProps(in nsIMsgImapFolderProps aFolderProps);
+  void resetNamespaceReferences();
+  void folderPrivileges(in nsIMsgWindow aWindow);
+  nsIMsgImapMailFolder findOnlineSubFolder(in ACString onlineName);
+  void addFolderRights(in ACString userName, in ACString rights);
+  void refreshFolderRights();
+
+  /**
+   * Mark/unmark the header as pending removal from the offline store. If mark,
+   * this also increases the expungedBytes count on the folder so we know
+   * there's more local disk space to be reclaimed.
+   *
+   * @param aHdr     msg hdr to mark pending removal from offline store.
+   * @param aMark    whether to set or clear the pending removal status.
+   *
+   */
+  void markPendingRemoval(in nsIMsgDBHdr aHdr, in boolean aMark);
+
+  /**
+   * Issue an expunge of this folder to the imap server.
+   *
+   * @param aUrlListener     url listener, can be null
+   * @param aWindow          msg window url is running in, can be null
+   *
+   * @returns                status of attempt to run url.
+   */
+  void expunge(in nsIUrlListener aListener, in nsIMsgWindow aMsgWindow);
+
+  void updateStatus(in nsIUrlListener aListener, in nsIMsgWindow aMsgWindow);
+  void updateFolderWithListener(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
+  // this is used to issue an arbitrary imap command on the passed in msgs.
+  // It assumes the command needs to be run in the selected state.
+  nsIURI issueCommandOnMsgs(in ACString command, in string uids, in nsIMsgWindow aWindow);
+  nsIURI fetchCustomMsgAttribute(in ACString msgAttribute, in string uids, in nsIMsgWindow aWindow);
+  nsIURI storeCustomKeywords(in nsIMsgWindow aMsgWindow,
+                      in ACString aFlagsToAdd,
+                      in ACString aFlagsToSubtract,
+                      [array, size_is (aNumKeys)] in nsMsgKey aKeysToStore,
+                      in unsigned long aNumKeys);
+
+  void notifyIfNewMail();
+
+  void initiateAutoSync(in nsIUrlListener aUrlListener);
+
+  attribute boolean verifiedAsOnlineFolder;
+  attribute boolean explicitlyVerify;
+  attribute char hierarchyDelimiter;
+  attribute long boxFlags;
+  attribute ACString onlineName;
+  attribute boolean isNamespace;
+  readonly attribute boolean canOpenFolder;
+  attribute ACString adminUrl;
+  readonly attribute boolean hasAdminUrl;
+  attribute boolean performingBiff;
+  readonly attribute nsIMsgParseMailMsgState hdrParser;
+  readonly attribute nsIImapIncomingServer imapIncomingServer;
+  readonly attribute nsIAutoSyncState autoSyncStateObj;
+  /**
+   * @{
+   * These are used to access the response to the STATUS or SELECT command.
+   * The counts include deleted messages, or headers we haven't downloaded yet.
+   */
+  readonly attribute long serverTotal;
+  readonly attribute long serverUnseen;
+  readonly attribute long serverRecent;
+  readonly attribute long serverNextUID;
+  /** @} */
+
+  /**
+   * Quota
+   * |valid| indicates whether the server has provided quota information on
+   * this folder. This can be false
+   * - if the server does not supports quotas,
+   * - if there are no storage quotas on this folder, or
+   * - if the folder has never been opened.
+   * If it is true and maxKB > 0, the folder has a storage quota and
+   * the usedKB and maxKB attributes are set to the values provided by
+   * the server (in kilobytes), for this quota root.
+   * Lotus Notes sends us maxKB = 0, usedKB > 0 for unlimited quota.
+   */
+  void getQuota(out boolean valid, out unsigned long usedKB, out unsigned long maxKB);
+
+  /**
+   * List all (human) users apart from the current user who have access to
+   * this folder.
+   *
+   * You can find out which rights they have with getRightsForUser().
+   */
+  nsIUTF8StringEnumerator getOtherUsersWithAccess();
+
+  /**
+   * Which access rights a certain user has for this folder.
+   *
+   * @return list of flags
+   * e.g. "lrswipcd" for write access and "lrs" for read only access.
+   *
+   * See RFC 2086 (e.g. Cyrus) and RFC 4314 (e.g. dovecot)
+   *
+   * l = locate = visible in folder list
+   * r = read = list mails, get/read mail contents
+   * s = set seen flag = mark read. Does not affect other users.
+   * d (or t) = delete mails
+   * w = write = change (other) flags of existing mails
+   * i = insert = add mails to this folder
+   * p = post = send mail directly to the submission address for folder
+   * c (or k) = create subfolders
+   * (e = expunge = compress)
+   * (x = delete folder)
+   * a = admin = change permissions
+   */
+  ACString getPermissionsForUser(in ACString username);
+
+  /**
+   * Change the number of "pending" messages in a folder,
+   *  messages we know about, but don't have the headers for yet
+   *
+   * @param aDelta amount to change total by.
+   */
+  void changePendingTotal(in long aDelta);
+
+  /**
+   * Change the number of "pending" unread messages in a folder,
+   * unread messages we know about, but don't have the headers for yet
+   *
+   * @param aDelta amount to change the unread count by.
+   */
+  void changePendingUnread(in long aDelta);
+};
diff --git a/mailnews/imap/public/nsMsgImapCID.h b/mailnews/imap/public/nsMsgImapCID.h
new file mode 100644
index 000000000..2ba83a28f
--- /dev/null
+++ b/mailnews/imap/public/nsMsgImapCID.h
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsMsgImapCID_h__
+#define nsMsgImapCID_h__
+
+#include "nsISupports.h"
+#include "nsIFactory.h"
+#include "nsIComponentManager.h"
+#include "nsMsgBaseCID.h"
+
+#define NS_IMAPURL_CID							\
+{ /* 21A89611-DC0D-11d2-806C-006008128C4E */	\
+  0x21a89611, 0xdc0d, 0x11d2,					\
+   { 0x80, 0x6c, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e }}
+
+#define NS_IMAPPROTOCOLINFO_CONTRACTID \
+  NS_MSGPROTOCOLINFO_CONTRACTID_PREFIX "imap"
+
+#define NS_IMAPINCOMINGSERVER_CONTRACTID  \
+  NS_MSGINCOMINGSERVER_CONTRACTID_PREFIX "imap"
+
+#define NS_IMAPSERVICE_CONTRACTID \
+  "@mozilla.org/messenger/imapservice;1"
+
+#define NS_IMAPSERVICE_CID						  \
+{ /* C5852B22-EBE2-11d2-95AD-000064657374 */      \
+ 0xc5852b22, 0xebe2, 0x11d2,                      \
+ {0x95, 0xad, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74}}
+
+#define NS_IMAPPROTOCOL_CID							\
+{ /* 8C0C40D1-E173-11d2-806E-006008128C4E */		\
+  0x8c0c40d1, 0xe173, 0x11d2,						\
+    { 0x80, 0x6e, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e }}
+
+
+#define NS_IIMAPHOSTSESSIONLIST_CID					\
+{ /* 479ce8fc-e725-11d2-a505-0060b0fc04b7 */		\
+  0x479ce8fc, 0xe725, 0x11d2,						\
+	{0xa5, 0x05, 0x00, 0x60, 0xb0, 0xfc, 0x04, 0xb7 }}
+
+#define NS_IMAPINCOMINGSERVER_CID				  \
+{ /* 8D3675E0-ED46-11d2-8077-006008128C4E */      \
+ 0x8d3675e0, 0xed46, 0x11d2,	                  \
+ {0x80, 0x77, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e}}
+
+#define NS_IMAPRESOURCE_CID						\
+{ /* fa32d000-f6a0-11d2-af8d-001083002da8 */	\
+  0xfa32d000, 0xf6a0, 0x11d2,					\
+  { 0xaf, 0x8d, 0x00, 0x10, 0x83, 0x00, 0x2d, 0xa8 }}
+
+// 4ECA51DF-6734-11d3-989A-001083010E9B
+#define NS_IMAPMOCKCHANNEL_CID \
+	{0x4eca51df, 0x6734, 0x11d3, \
+	{0x98, 0x9a, 0x0, 0x10, 0x83, 0x1, 0xe, 0x9b}}
+
+#endif // nsMsgImapCID_h__