decl namespace @name;
decl enum @name;
decl interface @name;
decl exception @name;
decl method @name;
decl struct @name;
decl basic @type @name;

namespace pEp {
    exception pEp_status {
        pEp_status_ok									> 0

        pEp_init_cannot_load_gpgme						> 0x0110
        pEp_init_gpgme_init_failed						> 0x0111
        pEp_init_no_gpg_home							> 0x0112
        pEp_init_netpgp_init_failed						> 0x0113

        pEp_init_sqlite3_without_mutex					> 0x0120
        pEp_init_cannot_open_db							> 0x0121
        pEp_init_cannot_open_system_db					> 0x0122
        
        pEp_key_not_found						        > 0x0201
        pEp_key_has_ambig_name					        > 0x0202
        pEp_get_key_failed						        > 0x0203
        
        pEp_cannot_find_identity						> 0x0301
        pEp_cannot_set_person							> 0x0381
        pEp_cannot_set_pgp_keypair						> 0x0382
        pEp_cannot_set_identity							> 0x0383
        pEp_cannot_set_trust                            > 0x0384
        
        pEp_unencrypted									> 0x0400
        pEp_verified									> 0x0401
        pEp_decrypted									> 0x0402
        pEp_decrypted_and_verified						> 0x0403
        pEp_decrypt_wrong_format						> 0x0404
        pEp_decrypt_no_key								> 0x0405
        pEp_decrypt_signature_does_not_match			> 0x0406
        pEp_verify_no_key                               > 0x0407
        pEp_verified_and_trusted                        > 0x0408
        pEp_cannot_decrypt_unknown						> 0x04ff

        pEp_trustword_not_found							> 0x0501

        pEp_cannot_create_key                           > 0x0601
        pEp_cannot_send_key                             > 0x0602

        pEp_phrase_not_found                            > 0x0701

        pEp_commit_failed								> 0xff01

        pEp_cannot_create_temp_file                     > -5
        pEp_illegal_value                               > -4
        pEp_buffer_too_small                            > -3
        pEp_out_of_memory								> -2
        pEp_unknown_error								> -1
    };

    enum Color {
        pEp_rating_undefined > 0
        pEp_rating_cannot_decrypt > 1
        pEp_rating_have_no_key > 2
        pEp_rating_unencrypted > 3
        pEp_rating_unencrypted_for_some > 4
        pEp_rating_unreliable > 5
        pEp_rating_reliable > 6
        pEp_rating_yellow > 6
        pEp_rating_trusted > 7
        pEp_rating_green > 7
        pEp_rating_trusted_and_anonymized > 8
        pEp_rating_fully_anonymous > 9

        pEp_rating_mistrust > -1
        pEp_rating_red > -1
        pEp_rating_b0rken > -2
        pEp_rating_under_attack > -3
    };

    enum DecryptFlags {
        pEp_decrypt_flag_own_private_key > 1
    };

    enum SyncHandshakeResult {
        sync_handshake_cancel   > -1
        sync_handshake_accepted > 0
        sync_handshake_rejected > 1
    };

    interface Engine {
        method encrypt_message(
                in message src,
                in stringlist extra,
                creates message dst,
                Cconst PEP_enc_format encformat "PEP_enc_PEP"
            );

        method encrypt_message_for_self(
                in identity target,
                in message src,
                creates message dst,
                Cconst PEP_enc_format encformat "PEP_enc_PEP"
            );
        
        method decrypt_message(
                in message src,
                creates message dst,
                creates stringlist keylist,
                returns Color color,
                returns DecryptFlags flags
            );

        method outgoing_message_color(
                in message msg,
                returns Color color
            );

        method get_identity(
                in string address,
                in string userid,
                returns identity ident
            );

        method identity_color(
                in identity ident,
                returns Color color
            );

        method blacklist_retrieve(
                returns stringlist blacklist
            );

        method own_message_private_key_details(
                in message msg,
                returns identity ident 
            );

        basic string trustwords(identity ident);
        basic identity myself(identity ident);
        basic identity updateIdentity(identity ident);
        basic void keyCompromized(identity ident);
        basic void keyResetTrust(identity ident);
        basic void trustPersonalKey(identity ident);
        basic void importKey(string key);
        basic void blacklist_add(string fpr);
        basic void blacklist_delete(string fpr);
        basic bool blacklist_is_listed(string fpr);
        basic void config_passive_mode(bool enable);
        basic void config_unencrypted_subject(bool enable);

    };

    struct message {
        enum TextFormat {
            plain       > 0
            html        > 1
            other       > 255
        }

        enum direction {
            incoming    > 0
            outgoing    > 1
        }

        enum EncFormat {
            none        > 0
            pieces      > 1
            SMIME       > 2
            PGPMIME     > 3
            PEP         > 4
        }

         direction dir;
         string id;
         string shortmsg;
         string longmsg;
         string longmsg_formatted;
         bloblist attachments;
         timestamp sent;
         timestamp recv;
         identity from;
         identitylist to;
         identity recv_by;
         identitylist cc;
         identitylist bcc;
         identitylist reply_to;
         stringlist in_reply_to;
         stringlist references;
         stringlist keywords;
         string comments;
         stringpairlist opt_fields;
         EncFormat enc_format;
    };
};