## CamelStore

CamelStore

## Synopsis

                        CamelStore;
    #define             CAMEL_STORE_ERROR
    enum                CamelStoreError;
                        CamelFolderInfo;
    #define             CAMEL_FOLDER_NOSELECT
    #define             CAMEL_FOLDER_NOINFERIORS
    #define             CAMEL_FOLDER_CHILDREN
    #define             CAMEL_FOLDER_NOCHILDREN
    #define             CAMEL_FOLDER_SUBSCRIBED
    #define             CAMEL_FOLDER_VIRTUAL
    #define             CAMEL_FOLDER_SYSTEM
    #define             CAMEL_FOLDER_VTRASH
    #define             CAMEL_FOLDER_SHARED_TO_ME
    #define             CAMEL_FOLDER_SHARED_BY_ME
    #define             CAMEL_FOLDER_TYPE_MASK
    #define             CAMEL_FOLDER_TYPE_BIT
    #define             CAMEL_FOLDER_TYPE_NORMAL
    #define             CAMEL_FOLDER_TYPE_INBOX
    #define             CAMEL_FOLDER_TYPE_OUTBOX
    #define             CAMEL_FOLDER_TYPE_TRASH
    #define             CAMEL_FOLDER_TYPE_JUNK
    #define             CAMEL_FOLDER_TYPE_SENT
    #define             CAMEL_STORE_READ
    #define             CAMEL_STORE_WRITE
    #define             CAMEL_STORE_SUBSCRIPTIONS
    #define             CAMEL_STORE_VTRASH
    #define             CAMEL_STORE_FILTER_INBOX
    #define             CAMEL_STORE_VJUNK
    #define             CAMEL_STORE_PROXY
    #define             CAMEL_STORE_IS_MIGRATING
    #define             CAMEL_STORE_ASYNC
    #define             CAMEL_STORE_REAL_JUNK_FOLDER
    #define             CAMEL_STORE_FOLDER_CREATE
    #define             CAMEL_STORE_FOLDER_EXCL
    #define             CAMEL_STORE_FOLDER_BODY_INDEX
    #define             CAMEL_STORE_FOLDER_PRIVATE
    #define             CAMEL_STORE_FOLDER_CREATE_EXCL
    #define             CAMEL_STORE_FOLDER_INFO_FAST
    #define             CAMEL_STORE_FOLDER_INFO_RECURSIVE
    #define             CAMEL_STORE_FOLDER_INFO_SUBSCRIBED
    #define             CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL
    #define             CAMEL_STORE_FOLDER_INFO_SUBSCRIPTION_LIST
    CamelFolder *       camel_store_get_folder              (CamelStore *store,
                                                             const gchar *folder_name,
                                                             guint32 flags,
                                                             GError **error);
    CamelFolder *       camel_store_get_inbox               (CamelStore *store,
                                                             GError **error);
    CamelFolder *       camel_store_get_trash               (CamelStore *store,
                                                             GError **error);
    CamelFolder *       camel_store_get_junk                (CamelStore *store,
                                                             GError **error);
    CamelFolderInfo *   camel_store_create_folder           (CamelStore *store,
                                                             const gchar *parent_name,
                                                             const gchar *folder_name,
                                                             GError **error);
    gboolean            camel_store_delete_folder           (CamelStore *store,
                                                             const gchar *folder_name,
                                                             GError **error);
    gboolean            camel_store_rename_folder           (CamelStore *store,
                                                             const gchar *old_namein,
                                                             const gchar *new_name,
                                                             GError **error);
    void                camel_store_folder_created          (CamelStore *store,
                                                             CamelFolderInfo *info);
    void                camel_store_folder_deleted          (CamelStore *store,
                                                             CamelFolderInfo *info);
    void                camel_store_folder_renamed          (CamelStore *store,
                                                             const gchar *old_name,
                                                             CamelFolderInfo *info);
    void                camel_store_folder_subscribed       (CamelStore *store,
                                                             CamelFolderInfo *info);
    void                camel_store_folder_unsubscribed     (CamelStore *store,
                                                             CamelFolderInfo *info);
    gboolean            camel_store_sync                    (CamelStore *store,
                                                             gint expunge,
                                                             GError **error);
    CamelFolderInfo *   camel_store_get_folder_info         (CamelStore *store,
                                                             const gchar *top,
                                                             guint32 flags,
                                                             GError **error);
    void                camel_store_free_folder_info        (CamelStore *store,
                                                             CamelFolderInfo *fi);
    void                camel_store_free_folder_info_full   (CamelStore *store,
                                                             CamelFolderInfo *fi);
    void                camel_store_free_folder_info_nop    (CamelStore *store,
                                                             CamelFolderInfo *fi);
    CamelFolderInfo *   camel_folder_info_new               (void);
    void                camel_folder_info_free              (CamelFolderInfo *fi);
    CamelFolderInfo *   camel_folder_info_build             (GPtrArray *folders,
                                                             const gchar *namespace,
                                                             gchar separator,
                                                             gboolean short_names);
    CamelFolderInfo *   camel_folder_info_clone             (CamelFolderInfo *fi);
    gboolean            camel_store_supports_subscriptions  (CamelStore *store);
    gboolean            camel_store_folder_is_subscribed    (CamelStore *store,
                                                             const gchar *folder_name);
    gboolean            camel_store_subscribe_folder        (CamelStore *store,
                                                             const gchar *folder_name,
                                                             GError **error);
    gboolean            camel_store_unsubscribe_folder      (CamelStore *store,
                                                             const gchar *folder_name,
                                                             GError **error);
    gboolean            camel_store_noop                    (CamelStore *store,
                                                             GError **error);
    gint                camel_store_folder_uri_equal        (CamelStore *store,
                                                             const gchar *uri0,
                                                             const gchar *uri1);
    gboolean            camel_store_can_refresh_folder      (CamelStore *store,
                                                             CamelFolderInfo *info,
                                                             GError **error);
    enum                CamelStoreLock;
    void                camel_store_lock                    (CamelStore *store,
                                                             CamelStoreLock lock);
    void                camel_store_unlock                  (CamelStore *store,
                                                             CamelStoreLock lock);

## Object Hierarchy

      GObject
       +----CamelObject
             +----CamelService
                   +----CamelStore
                         +----CamelDiscoStore
                         +----CamelOfflineStore
                         +----CamelVeeStore

## Signals

      "folder-created"                                 : Run First
      "folder-deleted"                                 : Run First
      "folder-opened"                                  : Run First
      "folder-renamed"                                 : Run First
      "folder-subscribed"                              : Run First
      "folder-unsubscribed"                            : Run First

## Description

## Details

### CamelStore

    typedef struct _CamelStore CamelStore;

### CAMEL_STORE_ERROR

    #define             CAMEL_STORE_ERROR

Since 2.32

### enum CamelStoreError

    typedef enum {
    	CAMEL_STORE_ERROR_INVALID,
    	CAMEL_STORE_ERROR_NO_FOLDER
    } CamelStoreError;

Since 2.32

### CamelFolderInfo

    typedef struct {
    	struct _CamelFolderInfo *next;
    	struct _CamelFolderInfo *parent;
    	struct _CamelFolderInfo *child;

    	gchar *uri;
    	gchar *name;
    	gchar *full_name;

    	guint32 flags;
    	gint32 unread;
    	gint32 total;
    } CamelFolderInfo;

### CAMEL_FOLDER_NOSELECT

    #define CAMEL_FOLDER_NOSELECT (1<<0)

### CAMEL_FOLDER_NOINFERIORS

    #define CAMEL_FOLDER_NOINFERIORS (1<<1)

### CAMEL_FOLDER_CHILDREN

    #define CAMEL_FOLDER_CHILDREN (1<<2)

### CAMEL_FOLDER_NOCHILDREN

    #define CAMEL_FOLDER_NOCHILDREN (1<<3)

### CAMEL_FOLDER_SUBSCRIBED

    #define CAMEL_FOLDER_SUBSCRIBED (1<<4)

### CAMEL_FOLDER_VIRTUAL

    #define CAMEL_FOLDER_VIRTUAL (1<<5)

### CAMEL_FOLDER_SYSTEM

    #define CAMEL_FOLDER_SYSTEM (1<<6)

### CAMEL_FOLDER_VTRASH

    #define CAMEL_FOLDER_VTRASH (1<<7)

### CAMEL_FOLDER_SHARED_TO_ME

    #define CAMEL_FOLDER_SHARED_TO_ME (1<<8)

### CAMEL_FOLDER_SHARED_BY_ME

    #define CAMEL_FOLDER_SHARED_BY_ME (1<<9)

### CAMEL_FOLDER_TYPE_MASK

    #define CAMEL_FOLDER_TYPE_MASK (7 << 10)

### CAMEL_FOLDER_TYPE_BIT

    #define CAMEL_FOLDER_TYPE_BIT (10)

### CAMEL_FOLDER_TYPE_NORMAL

    #define CAMEL_FOLDER_TYPE_NORMAL (0 << 10)

### CAMEL_FOLDER_TYPE_INBOX

    #define CAMEL_FOLDER_TYPE_INBOX (1 << 10)

### CAMEL_FOLDER_TYPE_OUTBOX

    #define CAMEL_FOLDER_TYPE_OUTBOX (2 << 10)

### CAMEL_FOLDER_TYPE_TRASH

    #define CAMEL_FOLDER_TYPE_TRASH (3 << 10)

### CAMEL_FOLDER_TYPE_JUNK

    #define CAMEL_FOLDER_TYPE_JUNK (4 << 10)

### CAMEL_FOLDER_TYPE_SENT

    #define CAMEL_FOLDER_TYPE_SENT (5 << 10)

### CAMEL_STORE_READ

    #define CAMEL_STORE_READ  (1 << 0)

### CAMEL_STORE_WRITE

    #define CAMEL_STORE_WRITE (1 << 1)

### CAMEL_STORE_SUBSCRIPTIONS

    #define CAMEL_STORE_SUBSCRIPTIONS (1 << 0)

### CAMEL_STORE_VTRASH

    #define CAMEL_STORE_VTRASH		(1 << 1)

### CAMEL_STORE_FILTER_INBOX

    #define CAMEL_STORE_FILTER_INBOX (1 << 2)

### CAMEL_STORE_VJUNK

    #define CAMEL_STORE_VJUNK		(1 << 3)

### CAMEL_STORE_PROXY

    #define CAMEL_STORE_PROXY		(1 << 4)

### CAMEL_STORE_IS_MIGRATING

    #define CAMEL_STORE_IS_MIGRATING (1 << 5)

Since 2.26

### CAMEL_STORE_ASYNC

    #define CAMEL_STORE_ASYNC		(1 << 6)

### CAMEL_STORE_REAL_JUNK_FOLDER

    #define CAMEL_STORE_REAL_JUNK_FOLDER (1 << 7)

Since 2.32

### CAMEL_STORE_FOLDER_CREATE

    #define CAMEL_STORE_FOLDER_CREATE (1<<0)

### CAMEL_STORE_FOLDER_EXCL

    #define CAMEL_STORE_FOLDER_EXCL (1<<1)

### CAMEL_STORE_FOLDER_BODY_INDEX

    #define CAMEL_STORE_FOLDER_BODY_INDEX (1<<2)

### CAMEL_STORE_FOLDER_PRIVATE

    #define CAMEL_STORE_FOLDER_PRIVATE (1<<3) /* a private folder, that shouldn't show up in unmatched/folder info's, etc */

### CAMEL_STORE_FOLDER_CREATE_EXCL

    #define CAMEL_STORE_FOLDER_CREATE_EXCL (CAMEL_STORE_FOLDER_CREATE | CAMEL_STORE_FOLDER_EXCL)

### CAMEL_STORE_FOLDER_INFO_FAST

    #define CAMEL_STORE_FOLDER_INFO_FAST       (1 << 0)

### Warning

`CAMEL_STORE_FOLDER_INFO_FAST` is deprecated and should not be used in newly-written code.

### CAMEL_STORE_FOLDER_INFO_RECURSIVE

    #define CAMEL_STORE_FOLDER_INFO_RECURSIVE  (1 << 1)

### CAMEL_STORE_FOLDER_INFO_SUBSCRIBED

    #define CAMEL_STORE_FOLDER_INFO_SUBSCRIBED (1 << 2)

### CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL

    #define CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL (1 << 3)  /* don't include vTrash/vJunk folders */

### CAMEL_STORE_FOLDER_INFO_SUBSCRIPTION_LIST

    #define CAMEL_STORE_FOLDER_INFO_SUBSCRIPTION_LIST (1 << 4)

Fetch only the subscription list. Clients should use this flag for requesting the list of folders available for subscription. Used in Exchange / IMAP connectors for public folder fetching.

Since 2.28

### camel_store_get_folder ()

    CamelFolder *       camel_store_get_folder              (CamelStore *store,
                                                             const gchar *folder_name,
                                                             guint32 flags,
                                                             GError **error);

Get a specific folder object from the store by name.

`store` : | a CamelStore object
`folder_name` : | name of the folder to get
`flags` : | folder flags (create, save body index, etc)
`error` : | return location for a GError, or `NULL`
Returns : | the folder corresponding to the path `folder_name` or `NULL`.

### camel_store_get_inbox ()

    CamelFolder *       camel_store_get_inbox               (CamelStore *store,
                                                             GError **error);

`store` : | a CamelStore object
`error` : | return location for a GError, or `NULL`
Returns : | the folder in the store into which new mail is delivered, or `NULL` if no such folder exists.

### camel_store_get_trash ()

    CamelFolder *       camel_store_get_trash               (CamelStore *store,
                                                             GError **error);

`store` : | a CamelStore object
`error` : | return location for a GError, or `NULL`
Returns : | the folder in the store into which trash is delivered, or `NULL` if no such folder exists.

### camel_store_get_junk ()

    CamelFolder *       camel_store_get_junk                (CamelStore *store,
                                                             GError **error);

`store` : | a CamelStore object
`error` : | return location for a GError, or `NULL`
Returns : | the folder in the store into which junk is delivered, or `NULL` if no such folder exists.

### camel_store_create_folder ()

    CamelFolderInfo *   camel_store_create_folder           (CamelStore *store,
                                                             const gchar *parent_name,
                                                             const gchar *folder_name,
                                                             GError **error);

Creates a new folder as a child of an existing folder. `parent_name` can be `NULL` to create a new top-level folder.

`store` : | a CamelStore object
`parent_name` : | name of the new folder's parent, or `NULL`
`folder_name` : | name of the folder to create
`error` : | return location for a GError, or `NULL`
Returns : | info about the created folder, which the caller must free with camel_store_free_folder_info, or `NULL`.

### camel_store_delete_folder ()

    gboolean            camel_store_delete_folder           (CamelStore *store,
                                                             const gchar *folder_name,
                                                             GError **error);

Deletes the named folder. The folder must be empty.

`store` : | a CamelStore object
`folder_name` : | name of the folder to delete
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

### camel_store_rename_folder ()

    gboolean            camel_store_rename_folder           (CamelStore *store,
                                                             const gchar *old_namein,
                                                             const gchar *new_name,
                                                             GError **error);

Rename a named folder to a new name.

`store` : | a CamelStore object
`old_namein` : | the current name of the folder
`new_name` : | the new name of the folder
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

### camel_store_folder_created ()

    void                camel_store_folder_created          (CamelStore *store,
                                                             CamelFolderInfo *info);

Emits the "folder-created" signal.

This function is only intended for Camel providers.

`store` : | a CamelStore
`info` : | information about the created folder

Since 2.32

### camel_store_folder_deleted ()

    void                camel_store_folder_deleted          (CamelStore *store,
                                                             CamelFolderInfo *info);

Emits the "folder-deleted" signal.

This function is only intended for Camel providers.

`store` : | a CamelStore
`info` : | information about the deleted folder

Since 2.32

### camel_store_folder_renamed ()

    void                camel_store_folder_renamed          (CamelStore *store,
                                                             const gchar *old_name,
                                                             CamelFolderInfo *info);

Emits the "folder-renamed" signal.

This function is only intended for Camel providers.

`store` : | a CamelStore
`old_name` : | the old name of the folder
`info` : | information about the renamed folder

Since 2.32

### camel_store_folder_subscribed ()

    void                camel_store_folder_subscribed       (CamelStore *store,
                                                             CamelFolderInfo *info);

Emits the "folder-subscribed" signal.

This function is only intended for Camel providers.

`store` : | a CamelStore
`info` : | information about the subscribed folder

Since 2.32

### camel_store_folder_unsubscribed ()

    void                camel_store_folder_unsubscribed     (CamelStore *store,
                                                             CamelFolderInfo *info);

Emits the "folder-unsubscribed" signal.

This function is only intended for Camel providers.

`store` : | a CamelStore
`info` : | information about the unsubscribed folder

Since 2.32

### camel_store_sync ()

    gboolean            camel_store_sync                    (CamelStore *store,
                                                             gint expunge,
                                                             GError **error);

Syncs any changes that have been made to the store object and its folders with the real store.

`store` : | a CamelStore object
`expunge` : | `TRUE` if an expunge should be done after sync or `FALSE` otherwise
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

### camel_store_get_folder_info ()

    CamelFolderInfo *   camel_store_get_folder_info         (CamelStore *store,
                                                             const gchar *top,
                                                             guint32 flags,
                                                             GError **error);

This fetches information about the folder structure of `store`, starting with `top`, and returns a tree of CamelFolderInfo structures. If `flags` includes CAMEL_STORE_FOLDER_INFO_SUBSCRIBED, only subscribed folders will be listed. If the store doesn't support subscriptions, then it will list all folders. If `flags` includes CAMEL_STORE_FOLDER_INFO_RECURSIVE, the returned tree will include all levels of hierarchy below `top`. If not, it will only include the immediate subfolders of `top`. If `flags` includes CAMEL_STORE_FOLDER_INFO_FAST, the unread_message_count fields of some or all of the structures may be set to `-1`, if the store cannot determine that information quickly. If `flags` includes CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, don't include special virtual folders (such as vTrash or vJunk).

The CAMEL_STORE_FOLDER_INFO_FAST flag should be considered deprecated; most backends will behave the same whether it is supplied or not. The only guaranteed way to get updated folder counts is to both open the folder and invoke `refresh_info()` it.

`store` : | a CamelStore object
`top` : | the name of the folder to start from
`flags` : | various CAMEL_STORE_FOLDER_INFO_* flags to control behavior
`error` : | return location for a GError, or `NULL`
Returns : | a CamelFolderInfo tree, which must be freed with camel_store_free_folder_info, or `NULL`.

### camel_store_free_folder_info ()

    void                camel_store_free_folder_info        (CamelStore *store,
                                                             CamelFolderInfo *fi);

Frees the data returned by camel_store_get_folder_info. If `fi` is `NULL`, nothing is done, the routine simply returns.

`store` : | a CamelStore object
`fi` : | a CamelFolderInfo as gotten via camel_store_get_folder_info

### camel_store_free_folder_info_full ()

    void                camel_store_free_folder_info_full   (CamelStore *store,
                                                             CamelFolderInfo *fi);

An implementation for "free_folder_info". Frees all of the data.

`store` : | a CamelStore object
`fi` : | a CamelFolderInfo as gotten via camel_store_get_folder_info

### camel_store_free_folder_info_nop ()

    void                camel_store_free_folder_info_nop    (CamelStore *store,
                                                             CamelFolderInfo *fi);

An implementation for "free_folder_info". Does nothing.

`store` : | a CamelStore object
`fi` : | a CamelFolderInfo as gotten via camel_store_get_folder_info

### camel_folder_info_new ()

    CamelFolderInfo *   camel_folder_info_new               (void);

Returns : | a new empty CamelFolderInfo instance

Since 2.22

### camel_folder_info_free ()

    void                camel_folder_info_free              (CamelFolderInfo *fi);

Frees `fi`.

`fi` : | a CamelFolderInfo

### camel_folder_info_build ()

    CamelFolderInfo *   camel_folder_info_build             (GPtrArray *folders,
                                                             const gchar *namespace,
                                                             gchar separator,
                                                             gboolean short_names);

### Warning

`camel_folder_info_build` is deprecated and should not be used in newly-written code.

This takes an array of folders and attaches them together according to the hierarchy described by their full_names and `separator`. If `namespace` is non-`NULL`, then it will be ignored as a full_name prefix, for purposes of comparison. If necessary, camel_folder_info_build will create additional CamelFolderInfo with `NULL` urls to fill in gaps in the tree. The value of `short_names` is used in constructing the names of these intermediate folders.

NOTE: This is deprected, do not use this. FIXME: remove this/move it to imap, which is the only user of it now.

`folders` : | an array of CamelFolderInfo
`namespace` : | an ignorable prefix on the folder names
`separator` : | the hieararchy separator character
`short_names` : | `TRUE` if the (short) name of a folder is the part after the last `separator` in the full name. `FALSE` if it is the full name.
Returns : | the top level of the tree of linked folder info.

### camel_folder_info_clone ()

    CamelFolderInfo *   camel_folder_info_clone             (CamelFolderInfo *fi);

Clones `fi` recursively.

`fi` : | a CamelFolderInfo
Returns : | the cloned CamelFolderInfo tree.

### camel_store_supports_subscriptions ()

    gboolean            camel_store_supports_subscriptions  (CamelStore *store);

Get whether or not `store` supports subscriptions to folders.

`store` : | a CamelStore object
Returns : | `TRUE` if folder subscriptions are supported or `FALSE` otherwise

### camel_store_folder_is_subscribed ()

    gboolean            camel_store_folder_is_subscribed    (CamelStore *store,
                                                             const gchar *folder_name);

Find out if a folder has been subscribed to.

`store` : | a CamelStore object
`folder_name` : | full path of the folder
Returns : | `TRUE` if the folder has been subscribed to or `FALSE` otherwise

### camel_store_subscribe_folder ()

    gboolean            camel_store_subscribe_folder        (CamelStore *store,
                                                             const gchar *folder_name,
                                                             GError **error);

Subscribe to the folder described by `folder_name`.

`store` : | a CamelStore object
`folder_name` : | full path of the folder
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

### camel_store_unsubscribe_folder ()

    gboolean            camel_store_unsubscribe_folder      (CamelStore *store,
                                                             const gchar *folder_name,
                                                             GError **error);

Unsubscribe from the folder described by `folder_name`.

`store` : | a CamelStore object
`folder_name` : | full path of the folder
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

### camel_store_noop ()

    gboolean            camel_store_noop                    (CamelStore *store,
                                                             GError **error);

Pings `store` so that its connection doesn't timeout.

`store` : | a CamelStore object
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

### camel_store_folder_uri_equal ()

    gint                camel_store_folder_uri_equal        (CamelStore *store,
                                                             const gchar *uri0,
                                                             const gchar *uri1);

Compares two folder uris to check that they are equal.

`store` : | a CamelStore object
`uri0` : | a folder uri
`uri1` : | another folder uri
Returns : | `TRUE` if they are equal or `FALSE` otherwise

### camel_store_can_refresh_folder ()

    gboolean            camel_store_can_refresh_folder      (CamelStore *store,
                                                             CamelFolderInfo *info,
                                                             GError **error);

Returns if this folder (param info) should be checked for new mail or not. It should not look into sub infos (info->child) or next infos, it should return value only for the actual folder info. Default behavior is that all Inbox folders are intended to be refreshed.

`store` : | a CamelStore
`info` : | a CamelFolderInfo
`error` : | return location for a GError, or `NULL`
Returns : | whether folder should be checked for new mails

Since 2.22

### enum CamelStoreLock

    typedef enum {
    	CAMEL_STORE_FOLDER_LOCK
    } CamelStoreLock;

Since 2.32

### camel_store_lock ()

    void                camel_store_lock                    (CamelStore *store,
                                                             CamelStoreLock lock);

Locks store's lock. Unlock it with `camel_store_unlock()`.

`store` : | a CamelStore
`lock` : | lock type to lock

Since 2.32

### camel_store_unlock ()

    void                camel_store_unlock                  (CamelStore *store,
                                                             CamelStoreLock lock);

Unlocks store's lock, previously locked with `camel_store_lock()`.

`store` : | a CamelStore
`lock` : | lock type to unlock

Since 2.32

## Signal Details

### The `"folder-created"` signal

    void                user_function                      (CamelStore *camelstore,
                                                            gpointer    arg1,
                                                            gpointer    user_data)       : Run First

`camelstore` : | the object which received the signal.
`Param2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"folder-deleted"` signal

    void                user_function                      (CamelStore *camelstore,
                                                            gpointer    arg1,
                                                            gpointer    user_data)       : Run First

`camelstore` : | the object which received the signal.
`Param2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"folder-opened"` signal

    void                user_function                      (CamelStore  *camelstore,
                                                            CamelFolder *arg1,
                                                            gpointer     user_data)       : Run First

`camelstore` : | the object which received the signal.
`Param2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"folder-renamed"` signal

    void                user_function                      (CamelStore *camelstore,
                                                            gchar      *arg1,
                                                            gpointer    arg2,
                                                            gpointer    user_data)       : Run First

`camelstore` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"folder-subscribed"` signal

    void                user_function                      (CamelStore *camelstore,
                                                            gpointer    arg1,
                                                            gpointer    user_data)       : Run First

`camelstore` : | the object which received the signal.
`Param2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"folder-unsubscribed"` signal

    void                user_function                      (CamelStore *camelstore,
                                                            gpointer    arg1,
                                                            gpointer    user_data)       : Run First

`camelstore` : | the object which received the signal.
`Param2` : |
`user_data` : | user data set when the signal handler was connected.