diff --git a/plugins/libkolab/lib/kolab_dav_client.php b/plugins/libkolab/lib/kolab_dav_client.php
index ee33d8d6..d9ae88da 100644
--- a/plugins/libkolab/lib/kolab_dav_client.php
+++ b/plugins/libkolab/lib/kolab_dav_client.php
@@ -1,512 +1,538 @@
 <?php
 
 /**
  * A *DAV client.
  *
  * @author Aleksander Machniak <machniak@apheleia-it.ch>
  *
  * Copyright (C) 2022, Apheleia IT AG <contact@apheleia-it.ch>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_dav_client
 {
     public $url;
 
     protected $user;
     protected $password;
     protected $rc;
     protected $responseHeaders = [];
 
     /**
      * Object constructor
      */
     public function __construct($url)
     {
         $this->rc = rcube::get_instance();
 
         $parsedUrl = parse_url($url);
 
         if (!empty($parsedUrl['user']) && !empty($parsedUrl['pass'])) {
             $this->user     = rawurldecode($parsedUrl['user']);
             $this->password = rawurldecode($parsedUrl['pass']);
 
             $url = str_replace(rawurlencode($this->user) . ':' . rawurlencode($this->password) . '@', '', $url);
         }
         else {
             $this->user     = $this->rc->user->get_username();
             $this->password = $this->rc->decrypt($_SESSION['password']);
         }
 
         $this->url = $url;
     }
 
     /**
      * Execute HTTP request to a DAV server
      */
     protected function request($path, $method, $body = '', $headers = [])
     {
         $rcube = rcube::get_instance();
         $debug = (array) $rcube->config->get('dav_debug');
 
         $request_config = [
             'store_body'       => true,
             'follow_redirects' => true,
         ];
 
         $this->responseHeaders = [];
 
         if ($path && ($rootPath = parse_url($this->url, PHP_URL_PATH)) && strpos($path, $rootPath) === 0) {
             $path = substr($path, strlen($rootPath));
         }
 
         try {
 
             $request = $this->initRequest($this->url . $path, $method, $request_config);
 
             $request->setAuth($this->user, $this->password);
 
             if ($body) {
                 $request->setBody($body);
                 $request->setHeader(['Content-Type' => 'application/xml; charset=utf-8']);
             }
 
             if (!empty($headers)) {
                 $request->setHeader($headers);
             }
 
             if ($debug) {
                 rcube::write_log('dav', "C: {$method}: " . (string) $request->getUrl()
                      . "\n" . $this->debugBody($body, $request->getHeaders()));
             }
 
             $response = $request->send();
 
             $body = $response->getBody();
             $code = $response->getStatus();
 
             if ($debug) {
                 rcube::write_log('dav', "S: [{$code}]\n" . $this->debugBody($body, $response->getHeader()));
             }
 
             if ($code >= 300) {
                 throw new Exception("DAV Error ($code):\n{$body}");
             }
 
             $this->responseHeaders = $response->getHeader();
 
             return $this->parseXML($body);
         }
         catch (Exception $e) {
             rcube::raise_error($e, true, false);
             return false;
         }
     }
 
     /**
      * Discover DAV folders of specified type on the server
      */
     public function discover($component = 'VEVENT')
     {
-/*
+        $roots = [
+            'VEVENT' => 'calendars',
+            'VTODO' => 'calendars',
+            'VCARD' => 'addressbooks',
+        ];
+
         $path = parse_url($this->url, PHP_URL_PATH);
 
         $body = '<?xml version="1.0" encoding="utf-8"?>'
             . '<d:propfind xmlns:d="DAV:">'
                 . '<d:prop>'
                     . '<d:current-user-principal />'
                 . '</d:prop>'
             . '</d:propfind>';
 
-        $response = $this->request('/calendars', 'PROPFIND', $body);
+        $response = $this->request('/' . $roots[$component], 'PROPFIND', $body);
 
         $elements = $response->getElementsByTagName('response');
 
         foreach ($elements as $element) {
             foreach ($element->getElementsByTagName('prop') as $prop) {
                 $principal_href = $prop->nodeValue;
                 break;
             }
         }
 
         if ($path && strpos($principal_href, $path) === 0) {
             $principal_href = substr($principal_href, strlen($path));
         }
 
         $body = '<?xml version="1.0" encoding="utf-8"?>'
             . '<d:propfind xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">'
                 . '<d:prop>'
                     . '<c:calendar-home-set />'
                 . '</d:prop>'
             . '</d:propfind>';
 
         $response = $this->request($principal_href, 'PROPFIND', $body);
-*/
-        $roots = [
-            'VEVENT' => 'calendars',
-            'VTODO' => 'calendars',
-            'VCARD' => 'addressbooks',
-        ];
 
-        $principal_href = '/' . $roots[$component] . '/' . rawurlencode($this->user);
+        $elements = $response->getElementsByTagName('response');
+
+        foreach ($elements as $element) {
+            foreach ($element->getElementsByTagName('prop') as $prop) {
+                $root_href = $prop->nodeValue;
+                break;
+            }
+        }
+
+        if (!empty($root_href)) {
+            if ($path && strpos($root_href, $path) === 0) {
+                $root_href = substr($root_href, strlen($path));
+            }
+        }
+        else {
+            // Kolab iRony's calendar root
+            $root_href = '/' . $roots[$component] . '/' . rawurlencode($this->user);
+        }
 
         $body = '<?xml version="1.0" encoding="utf-8"?>'
             . '<d:propfind xmlns:d="DAV:" xmlns:cs="http://calendarserver.org/ns/" xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:a="http://apple.com/ns/ical/">'
                 . '<d:prop>'
                     . '<d:resourcetype />'
                     . '<d:displayname />'
                     . '<cs:getctag />'
                     . '<c:supported-calendar-component-set />'
                     . '<a:calendar-color />'
                 . '</d:prop>'
             . '</d:propfind>';
 
-        $response = $this->request($principal_href, 'PROPFIND', $body);
+        $response = $this->request($root_href, 'PROPFIND', $body);
 
         if (empty($response)) {
             return false;
         }
 
         $folders = [];
 
         foreach ($response->getElementsByTagName('response') as $element) {
             $folder = $this->getFolderPropertiesFromResponse($element);
             if ($folder['type'] === $component) {
                 $folders[] = $folder;
             }
         }
 
         return $folders;
     }
 
     /**
      * Create a DAV object in a folder
      */
     public function create($location, $content)
     {
         $response = $this->request($location, 'PUT', $content, ['Content-Type' => 'text/calendar; charset=utf-8']);
 
         if ($response !== false) {
             $etag = $this->responseHeaders['etag'];
 
             if (preg_match('|^".*"$|', $etag)) {
                 $etag = substr($etag, 1, -1);
             }
 
             return $etag;
         }
 
         return false;
     }
 
     /**
      * Update a DAV object in a folder
      */
     public function update($location, $content)
     {
         return $this->create($location, $content);
     }
 
     /**
      * Delete a DAV object from a folder
      */
     public function delete($location)
     {
         $response = $this->request($location, 'DELETE', '', ['Depth' => 1, 'Prefer' => 'return-minimal']);
 
         return $response !== false;
     }
 
     /**
      * Fetch DAV objects metadata (ETag, href) a folder
      */
     public function getIndex($location, $component = 'VEVENT')
     {
         $queries = [
             'VEVENT' => 'calendar-query',
             'VTODO' => 'calendar-query',
             'VCARD' => 'addressbook-query',
         ];
 
         $ns = [
             'VEVENT' => 'caldav',
             'VTODO' => 'caldav',
             'VCARD' => 'carddav',
         ];
 
         $filter = '';
         if ($component != 'VCARD') {
             $filter = '<c:comp-filter name="VCALENDAR">'
                     . '<c:comp-filter name="' . $component . '" />'
                 . '</c:comp-filter>';
         }
 
         $body = '<?xml version="1.0" encoding="utf-8"?>'
             .' <c:' . $queries[$component] . ' xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:' . $ns[$component]. '">'
                 . '<d:prop>'
                     . '<d:getetag />'
                 . '</d:prop>'
                 . ($filter ? "<c:filter>$filter</c:filter>" : '')
             . '</c:' . $queries[$component] . '>';
 
         $response = $this->request($location, 'REPORT', $body, ['Depth' => 1, 'Prefer' => 'return-minimal']);
 
         if (empty($response)) {
             return false;
         }
 
         $objects = [];
 
         foreach ($response->getElementsByTagName('response') as $element) {
             $objects[] = $this->getObjectPropertiesFromResponse($element);
         }
 
         return $objects;
     }
 
     /**
      * Fetch DAV objects data from a folder
      */
     public function getData($location, $component = 'VEVENT', $hrefs = [])
     {
         if (empty($hrefs)) {
             return [];
         }
 
         $body = '';
         foreach ($hrefs as $href) {
             $body .= '<d:href>' . $href . '</d:href>';
         }
 
         $queries = [
             'VEVENT' => 'calendar-multiget',
             'VTODO' => 'calendar-multiget',
             'VCARD' => 'addressbook-multiget',
         ];
 
         $ns = [
             'VEVENT' => 'caldav',
             'VTODO' => 'caldav',
             'VCARD' => 'carddav',
         ];
 
         $types = [
             'VEVENT' => 'calendar-data',
             'VTODO' => 'calendar-data',
             'VCARD' => 'address-data',
         ];
 
         $body = '<?xml version="1.0" encoding="utf-8"?>'
             .' <c:' . $queries[$component] . ' xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:' . $ns[$component] . '">'
                 . '<d:prop>'
                     . '<d:getetag />'
                     . '<c:' . $types[$component]. ' />'
                 . '</d:prop>'
                 . $body
             . '</c:' . $queries[$component] . '>';
 
         $response = $this->request($location, 'REPORT', $body, ['Depth' => 1, 'Prefer' => 'return-minimal']);
 
         if (empty($response)) {
             return false;
         }
 
         $objects = [];
 
         foreach ($response->getElementsByTagName('response') as $element) {
             $objects[] = $this->getObjectPropertiesFromResponse($element);
         }
 
         return $objects;
     }
 
     /**
      * Parse XML content
      */
     protected function parseXML($xml)
     {
         $doc = new DOMDocument('1.0', 'UTF-8');
 
         if (stripos($xml, '<?xml') === 0) {
             if (!$doc->loadXML($xml)) {
                 throw new Exception("Failed to parse XML");
             }
 
             $doc->formatOutput = true;
         }
 
         return $doc;
     }
 
     /**
      * Parse request/response body for debug purposes
      */
     protected function debugBody($body, $headers)
     {
         $head = '';
         foreach ($headers as $header_name => $header_value) {
             $head .= "{$header_name}: {$header_value}\n";
         }
 
         if (stripos($body, '<?xml') === 0) {
             $doc = new DOMDocument('1.0', 'UTF-8');
 
+            $doc->formatOutput = true;
+            $doc->preserveWhiteSpace = false;
+
             if (!$doc->loadXML($body)) {
                 throw new Exception("Failed to parse XML");
             }
 
-            $doc->formatOutput = true;
-
             $body = $doc->saveXML();
         }
 
         return $head . "\n" . rtrim($body);
     }
 
     /**
      * Extract folder properties from a server 'response' element
      */
     protected function getFolderPropertiesFromResponse(DOMNode $element)
     {
 
         if ($href = $element->getElementsByTagName('href')->item(0)) {
             $href = $href->nodeValue;
 /*
             $path = parse_url($this->url, PHP_URL_PATH);
             if ($path && strpos($href, $path) === 0) {
                 $href = substr($href, strlen($path));
             }
 */
         }
 
         if ($color = $element->getElementsByTagName('calendar-color')->item(0)) {
             if (preg_match('/^#[0-9A-F]{8}$/', $color->nodeValue)) {
                 $color = substr($color->nodeValue, 1, -2);
             } else {
                 $color = null;
             }
         }
 
         if ($name = $element->getElementsByTagName('displayname')->item(0)) {
             $name = $name->nodeValue;
         }
 
         if ($ctag = $element->getElementsByTagName('getctag')->item(0)) {
             $ctag = $ctag->nodeValue;
         }
 
         $component = null;
         if ($set_element = $element->getElementsByTagName('supported-calendar-component-set')->item(0)) {
             if ($comp_element = $set_element->getElementsByTagName('comp')->item(0)) {
                 $component = $comp_element->attributes->getNamedItem('name')->nodeValue;
             }
         }
 
+        $types = [];
+        if ($type_element = $element->getElementsByTagName('resourcetype')->item(0)) {
+            foreach ($type_element->childNodes as $node) {
+                $_type = explode(':', $node->nodeName);
+                $types[] = count($_type) > 1 ? $_type[1] : $_type[0];
+            }
+        }
+
         return [
             'href' => $href,
             'name' => $name,
             'ctag' => $ctag,
             'color' => $color,
             'type' => $component,
+            'resource_type' => $types,
         ];
     }
 
     /**
      * Extract object properties from a server 'response' element
      */
     protected function getObjectPropertiesFromResponse(DOMNode $element)
     {
         $uid = null;
         if ($href = $element->getElementsByTagName('href')->item(0)) {
             $href = $href->nodeValue;
 /*
             $path = parse_url($this->url, PHP_URL_PATH);
             if ($path && strpos($href, $path) === 0) {
                 $href = substr($href, strlen($path));
             }
 */
             // Extract UID from the URL
             $href_parts = explode('/', $href);
             $uid = preg_replace('/\.[a-z]+$/', '', $href_parts[count($href_parts)-1]);
         }
 
         if ($data = $element->getElementsByTagName('calendar-data')->item(0)) {
             $data = $data->nodeValue;
         }
         else if ($data = $element->getElementsByTagName('address-data')->item(0)) {
             $data = $data->nodeValue;
         }
 
         if ($etag = $element->getElementsByTagName('getetag')->item(0)) {
             $etag = $etag->nodeValue;
             if (preg_match('|^".*"$|', $etag)) {
                 $etag = substr($etag, 1, -1);
             }
         }
 
         return [
             'href' => $href,
             'data' => $data,
             'etag' => $etag,
             'uid' => $uid,
         ];
     }
 
     /**
      * Initialize HTTP request object
      */
     protected function initRequest($url = '', $method = 'GET', $config = array())
     {
         $rcube       = rcube::get_instance();
         $http_config = (array) $rcube->config->get('kolab_http_request');
 
         // deprecated configuration options
         if (empty($http_config)) {
             foreach (array('ssl_verify_peer', 'ssl_verify_host') as $option) {
                 $value = $rcube->config->get('kolab_' . $option, true);
                 if (is_bool($value)) {
                     $http_config[$option] = $value;
                 }
             }
         }
 
         if (!empty($config)) {
             $http_config = array_merge($http_config, $config);
         }
 
         // load HTTP_Request2 (support both composer-installed and system-installed package)
         if (!class_exists('HTTP_Request2')) {
             require_once 'HTTP/Request2.php';
         }
 
         try {
             $request = new HTTP_Request2();
             $request->setConfig($http_config);
 
             // proxy User-Agent string
             $request->setHeader('user-agent', $_SERVER['HTTP_USER_AGENT']);
 
             // cleanup
             $request->setBody('');
             $request->setUrl($url);
             $request->setMethod($method);
 
             return $request;
         }
         catch (Exception $e) {
             rcube::raise_error($e, true, true);
         }
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_dav.php b/plugins/libkolab/lib/kolab_storage_dav.php
index 82e3d938..ce064178 100644
--- a/plugins/libkolab/lib/kolab_storage_dav.php
+++ b/plugins/libkolab/lib/kolab_storage_dav.php
@@ -1,482 +1,488 @@
 <?php
 
 /**
  * Kolab storage class providing access to groupware objects on a *DAV server.
  *
  * @author Aleksander Machniak <machniak@apheleia-it.ch>
  *
  * Copyright (C) 2022, Apheleia IT AG <contact@apheleia-it.ch>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_dav
 {
     const ERROR_DAV_CONN       = 1;
     const ERROR_CACHE_DB       = 2;
     const ERROR_NO_PERMISSION  = 3;
     const ERROR_INVALID_FOLDER = 4;
 
     protected $dav;
     protected $url;
 
 
     /**
      * Object constructor
      */
     public function __construct($url)
     {
         $this->url = $url;
         $this->setup();
     }
 
     /**
      * Setup the environment
      */
     public function setup()
     {
         $rcmail = rcube::get_instance();
 
         $this->config = $rcmail->config;
         $this->dav = new kolab_dav_client($this->url);
     }
 
     /**
      * Get a list of storage folders for the given data type
      *
      * @param string Data type to list folders for (contact,distribution-list,event,task,note)
      *
      * @return array List of kolab_storage_dav_folder objects
      */
     public function get_folders($type)
     {
         $davTypes = [
             'event' => 'VEVENT',
             'task'  => 'VTODO',
             'contact' => 'VCARD',
         ];
 
         // TODO: This should be cached
         $folders = $this->dav->discover($davTypes[$type]);
 
         if (is_array($folders)) {
             foreach ($folders as $idx => $folder) {
+                // Exclude some special folders
+                if (in_array('schedule-inbox', $folder['resource_type']) || in_array('schedule-outbox', $folder['resource_type'])) {
+                    unset($folders[$idx]);
+                    continue;
+                }
+
                 $folders[$idx] = new kolab_storage_dav_folder($this->dav, $folder, $type);
             }
         }
 
         return $folders ?: [];
     }
 
     /**
      * Getter for the storage folder for the given type
      *
      * @param string Data type to list folders for (contact,distribution-list,event,task,note)
      *
      * @return object kolab_storage_dav_folder The folder object
      */
     public function get_default_folder($type)
     {
         // TODO: Not used
     }
 
     /**
      * Getter for a specific storage folder
      *
      * @param string Folder to access
      * @param string Expected folder type
      *
      * @return object kolab_storage_folder The folder object
      */
     public function get_folder($folder, $type = null)
     {
         // TODO
     }
 
     /**
      * Getter for a single Kolab object, identified by its UID.
      * This will search all folders storing objects of the given type.
      *
      * @param string Object UID
      * @param string Object type (contact,event,task,journal,file,note,configuration)
      *
      * @return array The Kolab object represented as hash array or false if not found
      */
     public function get_object($uid, $type)
     {
         // TODO
         return false;
     }
 
     /**
      * Execute cross-folder searches with the given query.
      *
      * @param array  Pseudo-SQL query as list of filter parameter triplets
      * @param string Folder type (contact,event,task,journal,file,note,configuration)
      * @param int    Expected number of records or limit (for performance reasons)
      *
      * @return array List of Kolab data objects (each represented as hash array)
      */
     public function select($query, $type, $limit = null)
     {
         $result = [];
 
         foreach ($this->get_folders($type) as $folder) {
             if ($limit) {
                 $folder->set_order_and_limit(null, $limit);
             }
 
             foreach ($folder->select($query) as $object) {
                 $result[] = $object;
             }
         }
 
         return $result;
     }
 
     /**
      * Compose an URL to query the free/busy status for the given user
      *
      * @param string Email address of the user to get free/busy data for
      * @param object DateTime Start of the query range (optional)
      * @param object DateTime End of the query range (optional)
      *
      * @return string Fully qualified URL to query free/busy data
      */
     public static function get_freebusy_url($email, $start = null, $end = null)
     {
         return kolab_storage::get_freebusy_url($email, $start, $end);
     }
 
     /**
      * Deletes a folder
      *
      * @param string $name Folder name
      *
      * @return bool True on success, false on failure
      */
     public function folder_delete($name)
     {
         // TODO
     }
 
     /**
      * Creates a folder
      *
      * @param string $name       Folder name (UTF7-IMAP)
      * @param string $type       Folder type
      * @param bool   $subscribed Sets folder subscription
      * @param bool   $active     Sets folder state (client-side subscription)
      *
      * @return bool True on success, false on failure
      */
     public function folder_create($name, $type = null, $subscribed = false, $active = false)
     {
         // TODO
     }
 
     /**
      * Renames DAV folder
      *
      * @param string $oldname Old folder name (UTF7-IMAP)
      * @param string $newname New folder name (UTF7-IMAP)
      *
      * @return bool True on success, false on failure
      */
     public function folder_rename($oldname, $newname)
     {
         // TODO
     }
 
     /**
      * Rename or Create a new folder.
      *
      * Does additional checks for permissions and folder name restrictions
      *
      * @param array &$prop Hash array with folder properties and metadata
      *  - name:       Folder name
      *  - oldname:    Old folder name when changed
      *  - parent:     Parent folder to create the new one in
      *  - type:       Folder type to create
      *  - subscribed: Subscribed flag (IMAP subscription)
      *  - active:     Activation flag (client-side subscription)
      *
      * @return string|false New folder name or False on failure
      */
     public function folder_update(&$prop)
     {
         // TODO
     }
 
     /**
      * Getter for human-readable name of a folder
      *
      * @param string $folder    Folder name (UTF7-IMAP)
      * @param string $folder_ns Will be set to namespace name of the folder
      *
      * @return string Name of the folder-object
      */
     public static function object_name($folder, &$folder_ns = null)
     {
         // TODO: Shared folders
         $folder_ns = 'personal';
         return $folder;
     }
 
     /**
      * Creates a SELECT field with folders list
      *
      * @param string $type    Folder type
      * @param array  $attrs   SELECT field attributes (e.g. name)
      * @param string $current The name of current folder (to skip it)
      *
      * @return html_select SELECT object
      */
     public function folder_selector($type, $attrs, $current = '')
     {
         // TODO
     }
 
     /**
      * Returns a list of folder names
      *
      * @param string  Optional root folder
      * @param string  Optional name pattern
      * @param string  Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
      * @param bool    Enable to return subscribed folders only (null to use configured subscription mode)
      * @param array   Will be filled with folder-types data
      *
      * @return array List of folders
      */
     public function list_folders($root = '', $mbox = '*', $filter = null, $subscribed = null, &$folderdata = array())
     {
         // TODO
     }
 
     /**
      * Search for shared or otherwise not listed groupware folders the user has access
      *
      * @param string Folder type of folders to search for
      * @param string Search string
      * @param array  Namespace(s) to exclude results from
      *
      * @return array List of matching kolab_storage_folder objects
      */
     public function search_folders($type, $query, $exclude_ns = [])
     {
         // TODO
         return [];
     }
 
     /**
      * Sort the given list of folders by namespace/name
      *
      * @param array List of kolab_storage_dav_folder objects
      *
      * @return array Sorted list of folders
      */
     public static function sort_folders($folders)
     {
         // TODO
         return $folders;
     }
 
     /**
      * Returns folder types indexed by folder name
      *
      * @param string $prefix Folder prefix (Default '*' for all folders)
      *
      * @return array|bool List of folders, False on failure
      */
     public function folders_typedata($prefix = '*')
     {
         // TODO: Used by kolab_folders, kolab_activesync, kolab_delegation
         return [];
     }
 
     /**
      * Returns type of a DAV folder
      *
      * @param string $folder Folder name (UTF7-IMAP)
      *
      * @return string Folder type
      */
     public function folder_type($folder)
     {
         // TODO: Used by kolab_folders, kolab_activesync, kolab_delegation
         return 'event';
     }
 
     /**
      * Sets folder content-type.
      *
      * @param string $folder Folder name
      * @param string $type   Content type
      *
      * @return bool True on success, False otherwise
      */
     public function set_folder_type($folder, $type = 'mail')
     {
         // NOP: Used by kolab_folders, kolab_activesync, kolab_delegation
         return false;
     }
 
     /**
      * Check subscription status of this folder
      *
      * @param string $folder Folder name
      * @param bool   $temp   Include temporary/session subscriptions
      *
      * @return bool True if subscribed, false if not
      */
     public function folder_is_subscribed($folder, $temp = false)
     {
         // NOP
         return true;
     }
 
     /**
      * Change subscription status of this folder
      *
      * @param string $folder Folder name
      * @param bool   $temp   Only subscribe temporarily for the current session
      *
      * @return True on success, false on error
      */
     public function folder_subscribe($folder, $temp = false)
     {
         // NOP
         return true;
     }
 
     /**
      * Change subscription status of this folder
      *
      * @param string $folder Folder name
      * @param bool   $temp  Only remove temporary subscription
      *
      * @return True on success, false on error
      */
     public function folder_unsubscribe($folder, $temp = false)
     {
         // NOP
         return false;
     }
 
     /**
      * Check activation status of this folder
      *
      * @param string $folder Folder name
      *
      * @return bool True if active, false if not
      */
     public function folder_is_active($folder)
     {
         // TODO
         return true;
     }
 
     /**
      * Change activation status of this folder
      *
      * @param string $folder Folder name
      *
      * @return True on success, false on error
      */
     public function folder_activate($folder)
     {
         return true;
     }
 
     /**
      * Change activation status of this folder
      *
      * @param string $folder Folder name
      *
      * @return True on success, false on error
      */
     public function folder_deactivate($folder)
     {
         return false;
     }
 
     /**
      * Creates default folder of specified type
      * To be run when none of subscribed folders (of specified type) is found
      *
      * @param string $type  Folder type
      * @param string $props Folder properties (color, etc)
      *
      * @return string Folder name
      */
     public function create_default_folder($type, $props = [])
     {
         // TODO: For kolab_addressbook??
         return '';
     }
 
     /**
      * Returns a list of IMAP folders shared by the given user
      *
      * @param array  User entry from LDAP
      * @param string Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
      * @param int    1 - subscribed folders only, 0 - all folders, 2 - all non-active
      * @param array  Will be filled with folder-types data
      *
      * @return array List of folders
      */
     public function list_user_folders($user, $type, $subscribed = 0, &$folderdata = [])
     {
         // TODO
         return [];
     }
 
     /**
      * Get a list of (virtual) top-level folders from the other users namespace
      *
      * @param string Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
      * @param bool   Enable to return subscribed folders only (null to use configured subscription mode)
      *
      * @return array List of kolab_storage_folder_user objects
      */
     public function get_user_folders($type, $subscribed)
     {
         // TODO
         return [];
     }
 
     /**
      * Handler for user_delete plugin hooks
      *
      * Remove all cache data from the local database related to the given user.
      */
     public static function delete_user_folders($args)
     {
         $db = rcmail::get_instance()->get_dbh();
         $table  = $db->table_name('kolab_folders', true);
         $prefix = 'dav://' . urlencode($args['username']) . '@' . $args['host'] . '/%';
 
         $db->query("DELETE FROM $table WHERE `resource` LIKE ?", $prefix);
     }
 
     /**
      * Get folder METADATA for all supported keys
      * Do this in one go for better caching performance
      */
     public function folder_metadata($folder)
     {
         // TODO ?
         return [];
     }
 }