PHP Class Horde_Imap_Client_Base, horde

- cache: (array) If set, caches data from fetch(), search(), and
         thread() calls. Requires the horde/Cache package to be
         installed. The array can contain the following keys (see
         Horde_Imap_Client_Cache for default values):
  - backend: [REQUIRED (or cacheob)] (Horde_Imap_Client_Cache_Backend)
             Backend cache driver [@since 2.9.0].
  - fetch_ignore: (array) A list of mailboxes to ignore when storing
                  fetch data.
  - fields: (array) The fetch criteria to cache. If not defined, all
            cacheable data is cached. The following is a list of
            criteria that can be cached:
    - Horde_Imap_Client::FETCH_ENVELOPE
    - Horde_Imap_Client::FETCH_FLAGS
      Only if server supports CONDSTORE extension
    - Horde_Imap_Client::FETCH_HEADERS
      Only for queries that specifically request caching
    - Horde_Imap_Client::FETCH_IMAPDATE
    - Horde_Imap_Client::FETCH_SIZE
    - Horde_Imap_Client::FETCH_STRUCTURE
- capability_ignore: (array) A list of IMAP capabilites to ignore, even
                     if they are supported on the server.
                     DEFAULT: No supported capabilities are ignored.
- comparator: (string) The search comparator to use instead of the
              default server comparator. See setComparator() for
              format.
              DEFAULT: Use the server default
- context: (array) Any context parameters passed to
           stream_create_context(). @since 2.27.0
- debug: (string) If set, will output debug information to the stream
         provided. The value can be any PHP supported wrapper that can
         be opened via PHP's fopen() function.
         DEFAULT: No debug output
- hostspec: (string) The hostname or IP address of the server.
            DEFAULT: 'localhost'
- id: (array) Send ID information to the server (only if server
      supports the ID extension). An array with the keys as the fields
      to send and the values being the associated values. See RFC 2971
      [3.3] for a list of standard field values.
      DEFAULT: No info sent to server
- lang: (array) A list of languages (in priority order) to be used to
        display human readable messages.
        DEFAULT: Messages output in IMAP server default language
- password: (mixed) The user password. Either a string or a
            Horde_Imap_Client_Base_Password object [@since 2.14.0].
- port: (integer) The server port to which we will connect.
        DEFAULT: 143 (imap or imap w/TLS) or 993 (imaps)
- secure: (string) Use SSL or TLS to connect. Values:
  - false (No encryption)
  - 'ssl' (Auto-detect SSL version)
  - 'sslv2' (Force SSL version 3)
  - 'sslv3' (Force SSL version 2)
  - 'tls' (TLS; started via protocol-level negotation over
    unencrypted channel; RECOMMENDED way of initiating secure
    connection)
  - 'tlsv1' (TLS direct version 1.x connection to server) [@since
    2.16.0]
  - true (TLS if available/necessary) [@since 2.15.0]
    DEFAULT: false
- timeout: (integer)  Connection timeout, in seconds.
           DEFAULT: 30 seconds
- username: (string) [REQUIRED] The username.

  - data: (mixed) The data to append. If a string or a stream resource,
          this will be used as the entire contents of a single message.
          If an array, will catenate all given parts into a single
          message. This array contains one or more arrays with
          two keys:
    - t: (string) Either 'url' or 'text'.
    - v: (mixed) If 't' is 'url', this is the IMAP URL to the message
         part to append. If 't' is 'text', this is either a string or
         resource representation of the message part data.
    DEFAULT: NONE (entry is MANDATORY)
  - flags: (array) An array of flags/keywords to set on the appended
           message.
           DEFAULT: Only the \Recent flag is set.
  - internaldate: (DateTime) The internaldate to set for the appended
                  message.
                  DEFAULT: internaldate will be the same date as when
                  the message was appended.

  - create: (boolean) Try to create $mailbox if it does not exist?
            DEFAULT: No.

 - delimiter: (string) The namespace delimiter.
 - hidden: (boolean) Is this a hidden namespace?
 - name: (string) The namespace name (UTF-8).
 - translation: (string) Returns the translated name of the namespace
                (UTF-8). Requires RFC 5255 and a previous call to
                setLanguage().
 - type: (integer) The namespace type. Either:
   - Horde_Imap_Client::NS_PERSONAL
   - Horde_Imap_Client::NS_OTHER
   - Horde_Imap_Client::NS_SHARED

  - attributes: (boolean) If true, return attribute information under
                the 'attributes' key.
                DEFAULT: Do not return this information.
  - children: (boolean) Tell server to return children attribute
              information (\HasChildren, \HasNoChildren). Requires the
              LIST-EXTENDED extension to guarantee this information is
              returned. Server MAY return this attribute without this
              option, or if the CHILDREN extension is available, but it
              is not guaranteed.
              DEFAULT: false
  - flat: (boolean) If true, return a flat list of mailbox names only.
          Overrides the 'attributes' option.
          DEFAULT: Do not return flat list.
  - recursivematch: (boolean) Force the server to return information
                    about parent mailboxes that don't match other
                    selection options, but have some sub-mailboxes that
                    do. Information about children is returned in the
                    CHILDINFO extended data item ('extended'). Requires
                    the LIST-EXTENDED extension.
                    DEFAULT: false
  - remote: (boolean) Tell server to return mailboxes that reside on
            another server. Requires the LIST-EXTENDED extension.
            DEFAULT: false
  - special_use: (boolean) Tell server to return special-use attribute
                 information (see Horde_Imap_Client SPECIALUSE_*
                 constants). Server must support the SPECIAL-USE return
                 option for this setting to have any effect.
                 DEFAULT: false
  - status: (integer) Tell server to return status information. The
            value is a bitmask that may contain any of:
    - Horde_Imap_Client::STATUS_MESSAGES
    - Horde_Imap_Client::STATUS_RECENT
    - Horde_Imap_Client::STATUS_UIDNEXT
    - Horde_Imap_Client::STATUS_UIDVALIDITY
    - Horde_Imap_Client::STATUS_UNSEEN
    - Horde_Imap_Client::STATUS_HIGHESTMODSEQ
    DEFAULT: 0
  - sort: (boolean) If true, return a sorted list of mailboxes?
          DEFAULT: Do not sort the list.
  - sort_delimiter: (string) If 'sort' is true, this is the delimiter
                    used to sort the mailboxes.
                    DEFAULT: '.'

  - nocache: (boolean) Don't cache the results.
             DEFAULT: false (results cached, if possible)
  - partial: (mixed) The range of results to return (message sequence
             numbers) Only a single range is supported (represented by
             the minimum and maximum values contained in the range
             given).
             DEFAULT: All messages are returned.
  - results: (array) The data to return. Consists of zero or more of
             the following flags:
    - Horde_Imap_Client::SEARCH_RESULTS_COUNT
    - Horde_Imap_Client::SEARCH_RESULTS_MATCH (DEFAULT)
    - Horde_Imap_Client::SEARCH_RESULTS_MAX
    - Horde_Imap_Client::SEARCH_RESULTS_MIN
    - Horde_Imap_Client::SEARCH_RESULTS_SAVE
    - Horde_Imap_Client::SEARCH_RESULTS_RELEVANCY
  - sequence: (boolean) If true, returns an array of sequence numbers.
              DEFAULT: Returns an array of UIDs
  - sort: (array) Sort the returned list of messages. Multiple sort
          criteria can be specified. Any sort criteria can be sorted in
          reverse order (instead of the default ascending order) by
          adding a Horde_Imap_Client::SORT_REVERSE element to the array
          directly before adding the sort element. The following sort
          criteria are available:
    - Horde_Imap_Client::SORT_ARRIVAL
    - Horde_Imap_Client::SORT_CC
    - Horde_Imap_Client::SORT_DATE
    - Horde_Imap_Client::SORT_DISPLAYFROM
      On servers that don't support SORT=DISPLAY, this criteria will
      fallback to doing client-side sorting.
    - Horde_Imap_Client::SORT_DISPLAYFROM_FALLBACK
      On servers that don't support SORT=DISPLAY, this criteria will
      fallback to Horde_Imap_Client::SORT_FROM [since 2.4.0].
    - Horde_Imap_Client::SORT_DISPLAYTO
      On servers that don't support SORT=DISPLAY, this criteria will
      fallback to doing client-side sorting.
    - Horde_Imap_Client::SORT_DISPLAYTO_FALLBACK
      On servers that don't support SORT=DISPLAY, this criteria will
      fallback to Horde_Imap_Client::SORT_TO [since 2.4.0].
    - Horde_Imap_Client::SORT_FROM
    - Horde_Imap_Client::SORT_SEQUENCE
    - Horde_Imap_Client::SORT_SIZE
    - Horde_Imap_Client::SORT_SUBJECT
    - Horde_Imap_Client::SORT_TO

    [On servers that support SEARCH=FUZZY, this criteria is also
    available:]
    - Horde_Imap_Client::SORT_RELEVANCY

  - count: (integer) The number of messages that match the search
           criteria. Always returned.
  - match: (Horde_Imap_Client_Ids) The IDs that match $criteria, sorted
           if the 'sort' modifier was set. Returned if
           Horde_Imap_Client::SEARCH_RESULTS_MATCH is set.
  - max: (integer) The UID (default) or message sequence number (if
         'sequence' is true) of the highest message that satisifies
         $criteria. Returns null if no matches found. Returned if
         Horde_Imap_Client::SEARCH_RESULTS_MAX is set.
  - min: (integer) The UID (default) or message sequence number (if
         'sequence' is true) of the lowest message that satisifies
         $criteria. Returns null if no matches found. Returned if
         Horde_Imap_Client::SEARCH_RESULTS_MIN is set.
  - modseq: (integer) The highest mod-sequence for all messages being
           returned. Returned if 'sort' is false, the search query
           includes a MODSEQ command, and the server supports the
           CONDSTORE IMAP extension.
  - relevancy: (array) The list of relevancy scores. Returned if
               Horde_Imap_Client::SEARCH_RESULTS_RELEVANCY is set and
               the server supports FUZZY search matching.
  - save: (boolean) Whether the search results were saved. Returned if
          Horde_Imap_Client::SEARCH_RESULTS_SAVE is set.

  - Horde_Imap_Client::STATUS_MESSAGES
    Return key: messages
    Return format: (integer) The number of messages in the mailbox.

  - Horde_Imap_Client::STATUS_RECENT
    Return key: recent
    Return format: (integer) The number of messages with the \Recent
                   flag set as currently reported in the mailbox

  - Horde_Imap_Client::STATUS_RECENT_TOTAL
    Return key: recent_total
    Return format: (integer) The number of messages with the \Recent
                   flag set. This returns the total number of messages
                   that have been marked as recent in this mailbox
                   since the PHP process began. (since 2.12.0)

  - Horde_Imap_Client::STATUS_UIDNEXT
    Return key: uidnext
    Return format: (integer) The next UID to be assigned in the
                   mailbox. Only returned if the server automatically
                   provides the data.

  - Horde_Imap_Client::STATUS_UIDNEXT_FORCE
    Return key: uidnext
    Return format: (integer) The next UID to be assigned in the
                   mailbox. This option will always determine this
                   value, even if the server does not automatically
                   provide this data.

  - Horde_Imap_Client::STATUS_UIDVALIDITY
    Return key: uidvalidity
    Return format: (integer) The unique identifier validity of the
                   mailbox.

  - Horde_Imap_Client::STATUS_UNSEEN
    Return key: unseen
    Return format: (integer) The number of messages which do not have
                   the \Seen flag set.

  - Horde_Imap_Client::STATUS_FIRSTUNSEEN
    Return key: firstunseen
    Return format: (integer) The sequence number of the first unseen
                   message in the mailbox.

  - Horde_Imap_Client::STATUS_FLAGS
    Return key: flags
    Return format: (array) The list of defined flags in the mailbox
                   (all flags are in lowercase).

  - Horde_Imap_Client::STATUS_PERMFLAGS
    Return key: permflags
    Return format: (array) The list of flags that a client can change
                   permanently (all flags are in lowercase).

  - Horde_Imap_Client::STATUS_HIGHESTMODSEQ
    Return key: highestmodseq
    Return format: (integer) If the server supports the CONDSTORE
                   IMAP extension, this will be the highest
                   mod-sequence value of all messages in the mailbox.
                   Else 0 if CONDSTORE not available or the mailbox
                   does not support mod-sequences.

  - Horde_Imap_Client::STATUS_SYNCMODSEQ
    Return key: syncmodseq
    Return format: (integer) If caching, and the server supports the
                   CONDSTORE IMAP extension, this is the cached
                   mod-sequence value of the mailbox when it was opened
                   for the first time in this access. Will be null if
                   not caching, CONDSTORE not available, or the mailbox
                   does not support mod-sequences.

  - Horde_Imap_Client::STATUS_SYNCFLAGUIDS
    Return key: syncflaguids
    Return format: (Horde_Imap_Client_Ids) If caching, the server
                   supports the CONDSTORE IMAP extension, and the
                   mailbox contained cached data when opened for the
                   first time in this access, this is the list of UIDs
                   in which flags have changed since STATUS_SYNCMODSEQ.

  - Horde_Imap_Client::STATUS_SYNCVANISHED
    Return key: syncvanished
    Return format: (Horde_Imap_Client_Ids) If caching, the server
                   supports the CONDSTORE IMAP extension, and the
                   mailbox contained cached data when opened for the
                   first time in this access, this is the list of UIDs
                   which have been deleted since STATUS_SYNCMODSEQ.

  - Horde_Imap_Client::STATUS_UIDNOTSTICKY
    Return key: uidnotsticky
    Return format: (boolean) If the server supports the UIDPLUS IMAP
                   extension, and the queried mailbox does not support
                   persistent UIDs, this value will be true. In all
                   other cases, this value will be false.

  - Horde_Imap_Client::STATUS_FORCE_REFRESH
    Normally, the status information will be cached for a given
    mailbox. Since most PHP requests are generally less than a second,
    this is fine. However, if your script is long running, the status
    information may not be up-to-date. Specifying this flag will ensure
    that the server is always polled for the current mailbox status
    before results are returned. (since 2.14.0)

  - Horde_Imap_Client::STATUS_ALL (DEFAULT)
    Shortcut to return 'messages', 'recent', 'uidnext', 'uidvalidity',
    and 'unseen' values.

  - sort: (boolean) If true, sort the list of mailboxes? (since 2.10.0)
          DEFAULT: Do not sort the list.
  - sort_delimiter: (string) If 'sort' is true, this is the delimiter
                    used to sort the mailboxes. (since 2.10.0)
                    DEFAULT: '.'

  - criteria: (mixed) The following thread criteria are available:
    - Horde_Imap_Client::THREAD_ORDEREDSUBJECT
    - Horde_Imap_Client::THREAD_REFERENCES
    - Horde_Imap_Client::THREAD_REFS
      Other algorithms can be explicitly specified by passing the IMAP
      thread algorithm in as a string value.
    DEFAULT: Horde_Imap_Client::THREAD_ORDEREDSUBJECT
  - search: (Horde_Imap_Client_Search_Query) The search query.
            DEFAULT: All messages in mailbox included in thread sort.
  - sequence: (boolean) If true, each message is stored and referred to
              by its message sequence number.
              DEFAULT: Stored/referred to by UID.