diff --git a/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
index 1efdf5cf..c10c5d06 100644
--- a/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
+++ b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
@@ -1,176 +1,200 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  *
  * Author(s):
  *     Maximilian Krambach <mkrambach@intevation.de>
  */
 
 /* global describe, it, expect, before, Gpgmejs */
 /* global inputvalues, encryptedData, bigString, bigBoringString */
 
 describe('Encryption and Decryption', function (){
     let context = null;
     let good_fpr = inputvalues.encrypt.good.fingerprint;
 
     before(function (done){
         const prm = Gpgmejs.init();
         prm.then(function (gpgmejs){
             context = gpgmejs;
             done();
         });
     });
 
     it('Successful encrypt and decrypt simple string', function (done) {
         let data = inputvalues.encrypt.good.data;
         context.encrypt({ data: data, publicKeys: good_fpr }).then(
             function (answer) {
                 expect(answer).to.not.be.empty;
                 expect(answer.data).to.be.a('string');
                 expect(answer.data).to.include('BEGIN PGP MESSAGE');
                 expect(answer.data).to.include('END PGP MESSAGE');
                 context.decrypt({ data: answer.data }).then(function (result) {
                     expect(result).to.not.be.empty;
                     expect(result.data).to.be.a('string');
                     expect(result.data).to.equal(
                         inputvalues.encrypt.good.data);
                     done();
                 });
             });
     });
 
     it('Decrypt simple non-ascii', function (done) {
         let data = encryptedData;
         context.decrypt({ data: data }).then(function (result) {
             expect(result).to.not.be.empty;
             expect(result.data).to.be.a('string');
             expect(result.data).to.equal(
                 '¡Äußerste µ€ før ñoquis@hóme! Добрый день\n');
             done();
         });
     }).timeout(3000);
 
     it('Trailing whitespace and different line endings', function (done) {
         const data = 'Keks. \rKeks \n Keks \r\n';
         context.encrypt({ data: data, publicKeys: good_fpr }).then(
             function (answer) {
                 expect(answer).to.not.be.empty;
                 expect(answer.data).to.be.a('string');
                 expect(answer.data).to.include('BEGIN PGP MESSAGE');
                 expect(answer.data).to.include('END PGP MESSAGE');
 
                 context.decrypt({ data: answer.data }).then(function (result) {
                     expect(result).to.not.be.empty;
                     expect(result.data).to.be.a('string');
                     expect(result.data).to.equal(data);
                     done();
                 });
             });
     }).timeout(5000);
 
     it('Random data, as string', function (done) {
         let data = bigString(1000);
         context.encrypt({ data:data, publicKeys: good_fpr }).then(
             function (answer) {
                 expect(answer).to.not.be.empty;
                 expect(answer.data).to.be.a('string');
                 expect(answer.data).to.include(
                     'BEGIN PGP MESSAGE');
                 expect(answer.data).to.include(
                     'END PGP MESSAGE');
                 context.decrypt({ data: answer.data }).then(function (result) {
                     expect(result).to.not.be.empty;
                     expect(result.data).to.be.a('string');
                     expect(result.data).to.equal(data);
                     done();
                 });
             });
     }).timeout(3000);
 
     it('Data, input as base64', function (done) {
         let data = inputvalues.encrypt.good.data;
         let b64data = btoa(data);
         context.encrypt({ data: b64data, publicKeys: good_fpr, base64: true })
             .then(function (answer) {
                 expect(answer).to.not.be.empty;
                 expect(answer.data).to.be.a('string');
                 expect(answer.data).to.include(
                     'BEGIN PGP MESSAGE');
                 expect(answer.data).to.include(
                     'END PGP MESSAGE');
                 context.decrypt({ data: answer.data }).then(function (result) {
                     expect(result).to.not.be.empty;
                     expect(result.data).to.be.a('string');
                     expect(result.data).to.equal(data);
                     done();
                 });
             });
     }).timeout(3000);
 
     it('Random data, input as base64', function (done) {
         let data = bigBoringString(0.001);
         let b64data = btoa(data);
         context.encrypt(
             { data: b64data, publicKeys: good_fpr, base64: true })
             .then(function (answer) {
                 expect(answer).to.not.be.empty;
                 expect(answer.data).to.be.a('string');
                 expect(answer.data).to.include(
                     'BEGIN PGP MESSAGE');
                 expect(answer.data).to.include(
                     'END PGP MESSAGE');
                 context.decrypt({ data:answer.data }).then(
                     function (result) {
                         expect(result).to.not.be.empty;
                         expect(result.data).to.be.a('string');
                         expect(result.data).to.equal(data);
                         done();
                     });
             });
     }).timeout(3000);
 
+    it('Random data, original data is and should stay base64 encoded',
+        function (done) {
+            let data = bigBoringString(0.001);
+            let b64data = btoa(data);
+            context.encrypt(
+                { data: b64data, publicKeys: good_fpr })
+                .then(function (answer) {
+                    expect(answer).to.not.be.empty;
+                    expect(answer.data).to.be.a('string');
+                    expect(answer.data).to.include(
+                        'BEGIN PGP MESSAGE');
+                    expect(answer.data).to.include(
+                        'END PGP MESSAGE');
+                    context.decrypt({
+                        data:answer.data, expect: 'base64' })
+                        .then(function (result) {
+                            expect(result).to.not.be.empty;
+                            expect(result.data).to.be.a('string');
+                            expect(result.data).to.equal(b64data);
+                            done();
+                        });
+                });
+    }).timeout(3000);
+
     for (let j = 0; j < inputvalues.encrypt.good.data_nonascii_32.length; j++){
         it('Roundtrip with >1MB non-ascii input meeting default chunksize (' +
             (j + 1) + '/'
             + inputvalues.encrypt.good.data_nonascii_32.length + ')',
         function (done) {
             let input = inputvalues.encrypt.good.data_nonascii_32[j];
             expect(input).to.have.length(32);
             let data = '';
             for (let i=0; i < 34 * 1024; i++){
                 data += input;
             }
             context.encrypt({ data: data, publicKeys: good_fpr })
                 .then(function (answer) {
                     expect(answer).to.not.be.empty;
                     expect(answer.data).to.be.a('string');
                     expect(answer.data).to.include(
                         'BEGIN PGP MESSAGE');
                     expect(answer.data).to.include(
                         'END PGP MESSAGE');
                     context.decrypt({ data: answer.data })
                         .then(function (result) {
                             expect(result).to.not.be.empty;
                             expect(result.data).to.be.a('string');
                             expect(result.data).to.equal(data);
                             done();
                         });
                 });
         }).timeout(5000);
     }
 });
diff --git a/lang/js/src/Connection.js b/lang/js/src/Connection.js
index 8756cce1..3fd1810d 100644
--- a/lang/js/src/Connection.js
+++ b/lang/js/src/Connection.js
@@ -1,285 +1,288 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  *
  * Author(s):
  *     Maximilian Krambach <mkrambach@intevation.de>
  */
 
 /* global chrome */
 
 import { permittedOperations } from './permittedOperations';
 import { gpgme_error } from './Errors';
 import { GPGME_Message, createMessage } from './Message';
 import { decode, atobArray, Utf8ArrayToStr } from './Helpers';
 
 /**
  * A Connection handles the nativeMessaging interaction via a port. As the
  * protocol only allows up to 1MB of message sent from the nativeApp to the
  * browser, the connection will stay open until all parts of a communication
  * are finished. For a new request, a new port will open, to avoid mixing
  * contexts.
  * @class
  */
 export class Connection{
 
     constructor (){
         this._connection = chrome.runtime.connectNative('gpgmejson');
     }
 
     /**
      * Immediately closes an open port.
      */
     disconnect () {
         if (this._connection){
             this._connection.disconnect();
             this._connection = null;
         }
     }
 
 
     /**
     * @typedef {Object} backEndDetails
     * @property {String} gpgme Version number of gpgme
     * @property {Array<Object>} info Further information about the backend
     * and the used applications (Example:
     * {
     *          "protocol":     "OpenPGP",
     *          "fname":        "/usr/bin/gpg",
     *          "version":      "2.2.6",
     *          "req_version":  "1.4.0",
     *          "homedir":      "default"
     * }
     */
 
     /**
      * Retrieves the information about the backend.
      * @param {Boolean} details (optional) If set to false, the promise will
      *  just return if a connection was successful.
      * @returns {Promise<backEndDetails>|Promise<Boolean>} Details from the
      * backend
      * @async
      */
     checkConnection (details = true){
         const msg = createMessage('version');
         if (details === true) {
             return this.post(msg);
         } else {
             let me = this;
             return new Promise(function (resolve) {
                 Promise.race([
                     me.post(msg),
                     new Promise(function (resolve, reject){
                         setTimeout(function (){
                             reject(gpgme_error('CONN_TIMEOUT'));
                         }, 500);
                     })
                 ]).then(function (){ // success
                     resolve(true);
                 }, function (){ // failure
                     resolve(false);
                 });
             });
         }
     }
 
     /**
      * Sends a {@link GPGME_Message} via tghe nativeMessaging port. It
      * resolves with the completed answer after all parts have been
      * received and reassembled, or rejects with an {@link GPGME_Error}.
      *
      * @param {GPGME_Message} message
      * @returns {Promise<Object>} The collected answer
      * @async
      */
     post (message){
         if (!message || !(message instanceof GPGME_Message)){
             this.disconnect();
             return Promise.reject(gpgme_error(
                 'PARAM_WRONG', 'Connection.post'));
         }
         if (message.isComplete() !== true){
             this.disconnect();
             return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
         }
         let chunksize = message.chunksize;
         const me = this;
         return new Promise(function (resolve, reject){
             let answer = new Answer(message);
             let listener = function (msg) {
                 if (!msg){
                     me._connection.onMessage.removeListener(listener);
                     me._connection.disconnect();
                     reject(gpgme_error('CONN_EMPTY_GPG_ANSWER'));
                 } else {
                     let answer_result = answer.collect(msg);
                     if (answer_result !== true){
                         me._connection.onMessage.removeListener(listener);
                         me._connection.disconnect();
                         reject(answer_result);
                     } else {
                         if (msg.more === true){
                             me._connection.postMessage({
                                 'op': 'getmore',
                                 'chunksize': chunksize
                             });
                         } else {
                             me._connection.onMessage.removeListener(listener);
                             me._connection.disconnect();
                             const message = answer.getMessage();
                             if (message instanceof Error){
                                 reject(message);
                             } else {
                                 resolve(message);
                             }
                         }
                     }
                 }
             };
             me._connection.onMessage.addListener(listener);
             if (permittedOperations[message.operation].pinentry){
                 return me._connection.postMessage(message.message);
             } else {
                 return Promise.race([
                     me._connection.postMessage(message.message),
                     function (resolve, reject){
                         setTimeout(function (){
                             me._connection.disconnect();
                             reject(gpgme_error('CONN_TIMEOUT'));
                         }, 5000);
                     }
                 ]).then(function (result){
                     return result;
                 }, function (reject){
                     if (!(reject instanceof Error)) {
                         me._connection.disconnect();
                         return gpgme_error('GNUPG_ERROR', reject);
                     } else {
                         return reject;
                     }
                 });
             }
         });
     }
 }
 
 
 /**
  * A class for answer objects, checking and processing the return messages of
  * the nativeMessaging communication.
  * @protected
  */
 class Answer{
 
     /**
      * @param {GPGME_Message} message
      */
     constructor (message){
         this._operation = message.operation;
         this._expected = message.expected;
         this._response_b64 = null;
     }
 
     get operation (){
         return this._operation;
     }
 
     get expected (){
         return this._expected;
     }
 
     /**
      * Adds incoming base64 encoded data to the existing response
      * @param {*} msg base64 encoded data.
      * @returns {Boolean}
      *
      * @private
      */
     collect (msg){
         if (typeof (msg) !== 'object' || !msg.hasOwnProperty('response')) {
             return gpgme_error('CONN_UNEXPECTED_ANSWER');
         }
         if (!this._response_b64){
             this._response_b64 = msg.response;
             return true;
         } else {
             this._response_b64 += msg.response;
             return true;
         }
     }
     /**
      * Decodes and verifies the base64 encoded answer data. Verified against
      * {@link permittedOperations}.
      * @returns {Object} The readable gpnupg answer
      */
     getMessage (){
         if (this._response_b64 === null){
             return gpgme_error('CONN_UNEXPECTED_ANSWER');
         }
         let _decodedResponse = JSON.parse(atob(this._response_b64));
         let _response = {};
         let messageKeys = Object.keys(_decodedResponse);
         let poa = permittedOperations[this.operation].answer;
         if (messageKeys.length === 0){
             return gpgme_error('CONN_UNEXPECTED_ANSWER');
         }
         for (let i= 0; i < messageKeys.length; i++){
             let key = messageKeys[i];
             switch (key) {
             case 'type':
                 if (_decodedResponse.type === 'error'){
                     return (gpgme_error('GNUPG_ERROR',
                         decode(_decodedResponse.msg)));
                 } else if (poa.type.indexOf(_decodedResponse.type) < 0){
                     return gpgme_error('CONN_UNEXPECTED_ANSWER');
                 }
                 break;
             case 'base64':
                 break;
             case 'msg':
                 if (_decodedResponse.type === 'error'){
                     return (gpgme_error('GNUPG_ERROR', _decodedResponse.msg));
                 }
                 break;
             default:
                 if (!poa.data.hasOwnProperty(key)){
                     return gpgme_error('CONN_UNEXPECTED_ANSWER');
                 }
                 if ( typeof (_decodedResponse[key]) !== poa.data[key] ){
                     return gpgme_error('CONN_UNEXPECTED_ANSWER');
                 }
                 if (_decodedResponse.base64 === true
                     && poa.data[key] === 'string'
                 ) {
-                    if (this.expected === 'binary'){
+                    if (this.expected === 'uint8'){
                         _response[key] = atobArray(_decodedResponse[key]);
-                        _response.binary = true;
+                        _response.format = 'uint8';
+                    } else if (this.expected === 'base64'){
+                        _response[key] = _decodedResponse[key];
+                        _response.format = 'base64';
                     } else {
                         _response[key] = Utf8ArrayToStr(
                             atobArray(_decodedResponse[key]));
-                        _response.binary = false;
+                        _response.format = 'string';
                     }
                 } else {
                     _response[key] = decode(_decodedResponse[key]);
                 }
                 break;
             }
         }
         return _response;
     }
 }
diff --git a/lang/js/src/Message.js b/lang/js/src/Message.js
index 48813df7..fff20fbe 100644
--- a/lang/js/src/Message.js
+++ b/lang/js/src/Message.js
@@ -1,239 +1,239 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  *
  * Author(s):
  *     Maximilian Krambach <mkrambach@intevation.de>
  */
 
 import { permittedOperations } from './permittedOperations';
 import { gpgme_error } from './Errors';
 import { Connection } from './Connection';
 
 /**
  * Initializes a message for gnupg, validating the message's purpose with
  *   {@link permittedOperations} first
  * @param {String} operation
  * @returns {GPGME_Message} The Message object
  */
 export function createMessage (operation){
     if (typeof (operation) !== 'string'){
         throw gpgme_error('PARAM_WRONG');
     }
     if (permittedOperations.hasOwnProperty(operation)){
         return new GPGME_Message(operation);
     } else {
         throw gpgme_error('MSG_WRONG_OP');
     }
 }
 
 /**
  * A Message collects, validates and handles all information required to
  * successfully establish a meaningful communication with gpgme-json via
  * {@link Connection.post}. The definition on which communication is available
  * can be found in {@link permittedOperations}.
  * @class
  */
 export class GPGME_Message {
 
     constructor (operation){
         this._msg = {
             op: operation,
             chunksize: 1023* 1024
         };
         this._expected = null;
     }
 
     get operation (){
         return this._msg.op;
     }
 
     set expected (value){
-        if (value === 'binary'){
+        if (value === 'uint8' || value === 'base64'){
             this._expected = value;
         }
     }
 
     get expected () {
         return this._expected;
     }
     /**
      * The maximum size of responses from gpgme in bytes. As of July 2018,
      * most browsers will only accept answers up to 1 MB of size.
      * Everything above that threshold will not pass through
      * nativeMessaging; answers that are larger need to be sent in parts.
      * The lower limit is set to 10 KB. Messages smaller than the threshold
      * will not encounter problems, larger messages will be received in
      * chunks. If the value is not explicitly specified, 1023 KB is used.
      */
     set chunksize (value){
         if (
             Number.isInteger(value) &&
             value > 10 * 1024 &&
             value <= 1024 * 1024
         ){
             this._msg.chunksize = value;
         }
     }
 
     get chunksize (){
         return this._msg.chunksize;
     }
 
     /**
      * Returns the prepared message with parameters and completeness checked
      * @returns {Object|null} Object to be posted to gnupg, or null if
      * incomplete
      */
     get message () {
         if (this.isComplete() === true){
             return this._msg;
         } else {
             return null;
         }
     }
 
     /**
      * Sets a parameter for the message. It validates with
      *      {@link permittedOperations}
      * @param {String} param Parameter to set
      * @param {any} value Value to set
      * @returns {Boolean} If the parameter was set successfully
      */
     setParameter ( param,value ){
         if (!param || typeof (param) !== 'string'){
             throw gpgme_error('PARAM_WRONG');
         }
         let po = permittedOperations[this._msg.op];
         if (!po){
             throw gpgme_error('MSG_WRONG_OP');
         }
         let poparam = null;
         if (po.required.hasOwnProperty(param)){
             poparam = po.required[param];
         } else if (po.optional.hasOwnProperty(param)){
             poparam = po.optional[param];
         } else {
             throw gpgme_error('PARAM_WRONG');
         }
         // check incoming value for correctness
         let checktype = function (val){
             switch (typeof (val)){
             case 'string':
                 if (poparam.allowed.indexOf(typeof (val)) >= 0
                         && val.length > 0) {
                     return true;
                 }
                 throw gpgme_error('PARAM_WRONG');
             case 'number':
                 if (
                     poparam.allowed.indexOf('number') >= 0
                         && isNaN(value) === false){
                     return true;
                 }
                 throw gpgme_error('PARAM_WRONG');
 
             case 'boolean':
                 if (poparam.allowed.indexOf('boolean') >= 0){
                     return true;
                 }
                 throw gpgme_error('PARAM_WRONG');
             case 'object':
                 if (Array.isArray(val)){
                     if (poparam.array_allowed !== true){
                         throw gpgme_error('PARAM_WRONG');
                     }
                     for (let i=0; i < val.length; i++){
                         let res = checktype(val[i]);
                         if (res !== true){
                             return res;
                         }
                     }
                     if (val.length > 0) {
                         return true;
                     }
                 } else if (val instanceof Uint8Array){
                     if (poparam.allowed.indexOf('Uint8Array') >= 0){
                         return true;
                     }
                     throw gpgme_error('PARAM_WRONG');
                 } else {
                     throw gpgme_error('PARAM_WRONG');
                 }
                 break;
             default:
                 throw gpgme_error('PARAM_WRONG');
             }
         };
         let typechecked = checktype(value);
         if (typechecked !== true){
             return typechecked;
         }
         if (poparam.hasOwnProperty('allowed_data')){
             if (poparam.allowed_data.indexOf(value) < 0){
                 return gpgme_error('PARAM_WRONG');
             }
         }
         this._msg[param] = value;
         return true;
     }
 
 
     /**
      * Check if the message has the minimum requirements to be sent, that is
      * all 'required' parameters according to {@link permittedOperations}.
      * @returns {Boolean} true if message is complete.
      */
     isComplete (){
         if (!this._msg.op){
             return false;
         }
         let reqParams = Object.keys(
             permittedOperations[this._msg.op].required);
         let msg_params = Object.keys(this._msg);
         for (let i=0; i < reqParams.length; i++){
             if (msg_params.indexOf(reqParams[i]) < 0){
                 return false;
             }
         }
         return true;
     }
     /**
      * Sends the Message via nativeMessaging and resolves with the answer.
      * @returns {Promise<Object|GPGME_Error>}
      * @async
      */
     post (){
         let me = this;
         return new Promise(function (resolve, reject) {
             if (me.isComplete() === true) {
 
                 let conn  = new Connection;
                 conn.post(me).then(function (response) {
                     resolve(response);
                 }, function (reason) {
                     reject(reason);
                 });
             }
             else {
                 reject(gpgme_error('MSG_INCOMPLETE'));
             }
         });
     }
 
 }
diff --git a/lang/js/src/gpgmejs.js b/lang/js/src/gpgmejs.js
index e0398423..ac640308 100644
--- a/lang/js/src/gpgmejs.js
+++ b/lang/js/src/gpgmejs.js
@@ -1,422 +1,427 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  *
  * Author(s):
  *     Maximilian Krambach <mkrambach@intevation.de>
  */
 
 
 import { GPGME_Message, createMessage } from './Message';
 import { toKeyIdArray } from './Helpers';
 import { gpgme_error } from './Errors';
 import { GPGME_Keyring } from './Keyring';
 import { createSignature } from './Signature';
 
 /**
  * @typedef {Object} decrypt_result
  * @property {String|Uint8Array} data The decrypted data
- * @property {Boolean} binary indicating whether data is an Uint8Array.
+ * @property {String} format Indicating how the data was converted after being
+ * received from gpgme.
+ *      'string': Data was decoded into an utf-8 string,
+ *      'base64': Data was not processed and is a base64 string
+ *      'uint8': data was turned into a Uint8Array
  * @property {Boolean} is_mime (optional) the data claims to be a MIME
  * object.
  * @property {String} file_name (optional) the original file name
  * @property {signatureDetails} signatures Verification details for
  * signatures
  */
 
 /**
  * @typedef {Object} signatureDetails
  * @property {Boolean} all_valid Summary if all signatures are fully valid
  * @property {Number} count Number of signatures found
  * @property {Number} failures Number of invalid signatures
  * @property {Array<GPGME_Signature>} signatures.good All valid signatures
  * @property {Array<GPGME_Signature>} signatures.bad All invalid signatures
  */
 
 /**
  * @typedef {Object} encrypt_result The result of an encrypt operation
  * @property {String} data The encrypted message
- * @property {Boolean} binary Indicating whether returning payload data is an
- * Uint8Array.
+ * @property {Boolean} base64 Indicating whether returning payload data is
+ * base64 encoded
  */
 
 /**
  * @typedef { GPGME_Key | String | Object } inputKeys
  * Accepts different identifiers of a gnupg Key that can be parsed by
  * {@link toKeyIdArray}. Expected inputs are: One or an array of
  * GPGME_Keys; one or an array of fingerprint strings; one or an array of
  * openpgpjs Key objects.
  */
 
 /**
  * @typedef {Object} signResult The result of a signing operation
  * @property {String} data The resulting data. Includes the signature in
  *  clearsign mode
  * @property {String} signature The detached signature (if in detached mode)
  */
 
 /** @typedef {Object} verifyResult The result of a verification
  * @property {Boolean} data: The verified data
  * @property {Boolean} is_mime (optional) the data claims to be a MIME
  * object.
  * @property {String} file_name (optional) the original file name
  * @property {signatureDetails} signatures Verification details for
  * signatures
  */
 
 /**
  * The main entry point for gpgme.js.
  * @class
  */
 export class GpgME {
 
     constructor (){
         this._Keyring = null;
     }
 
     /**
      * setter for {@link setKeyring}.
      * @param {GPGME_Keyring} keyring A Keyring to use
      */
     set Keyring (keyring){
         if (keyring && keyring instanceof GPGME_Keyring){
             this._Keyring = keyring;
         }
     }
     /**
      * Accesses the {@link GPGME_Keyring}.
      */
     get Keyring (){
         if (!this._Keyring){
             this._Keyring = new GPGME_Keyring;
         }
         return this._Keyring;
     }
 
     /**
      * Encrypt (and optionally sign) data
      * @param {Object} options
      * @param {String|Object} options.data text/data to be encrypted as String.
      * Also accepts Objects with a getText method
      * @param {inputKeys} options.publicKeys
      * Keys used to encrypt the message
      * @param {inputKeys} opions.secretKeys (optional) Keys used to sign the
      * message. If Keys are present, the  operation requested is assumed
      * to be 'encrypt and sign'
      * @param {Boolean} options.base64 (optional) The data will be interpreted
      * as base64 encoded data.
      * @param {Boolean} options.armor (optional) Request the output as armored
      * block.
      * @param {Boolean} options.wildcard (optional) If true, recipient
      * information will not be added to the message.
      * @param {Object} additional use additional valid gpg options as
      * defined in {@link permittedOperations}
      * @returns {Promise<encrypt_result>} Object containing the encrypted
      * message and additional info.
      * @async
      */
     encrypt (options){
         if (!options || (typeof options !== 'object')){
             return Promise.reject(gpgme_error('PARAM_WRONG'));
         }
         if (!options.hasOwnProperty('data')
             || !options.hasOwnProperty('publicKeys')
         ){
             return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
         }
         let msg = createMessage('encrypt');
         if (msg instanceof Error){
             return Promise.reject(msg);
         }
         if (!options.hasOwnProperty('armor')){
             options.armor = true;
         }
         msg.setParameter('armor', options.armor);
 
         if (options.base64 === true) {
             msg.setParameter('base64', true);
         }
         let pubkeys = toKeyIdArray(options.publicKeys);
         msg.setParameter('keys', pubkeys);
         let sigkeys = toKeyIdArray(options.secretKeys);
         if (sigkeys.length > 0) {
             msg.setParameter('signing_keys', sigkeys);
         }
         putData(msg, options.data);
         if (options.wildcard === true){
             msg.setParameter('throw-keyids', true);
         }
         if (options.additional){
             let additional_Keys = Object.keys(options.additional);
             for (let k = 0; k < additional_Keys.length; k++) {
                 try {
                     msg.setParameter(additional_Keys[k],
                         options.additional[additional_Keys[k]]);
                 }
                 catch (error){
                     return Promise.reject(error);
                 }
             }
         }
         if (msg.isComplete() === true){
             return msg.post();
         } else {
             return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
         }
     }
 
     /**
     * Decrypts a Message
     * @param {Object} options
     * @param {String|Object} options.data text/data to be decrypted. Accepts
     * Strings and Objects with a getText method
     * @param {Boolean} options.base64 (optional) false if the data is an
     * armored block, true if it is base64 encoded binary data
-    * @param {Boolean} options.binary (optional) if true, treat the decoded
-    * data as binary, and return the data as Uint8Array
+    * @param {String} options.expect (optional) can be set to 'uint8' or
+    * 'base64'. Does no extra decoding on the data, and returns the decoded
+    * data as either Uint8Array or unprocessed(base64 encoded) string.
     * @returns {Promise<decrypt_result>} Decrypted Message and information
     * @async
     */
     decrypt (options){
         if (!options || (typeof options !== 'object')){
             return Promise.reject('PARAM_WRONG');
         }
         if (!options.data){
             return Promise.reject(gpgme_error('MSG_EMPTY'));
         }
         let msg = createMessage('decrypt');
 
         if (msg instanceof Error){
             return Promise.reject(msg);
         }
         if (options.base64 === true){
             msg.setParameter('base64', true);
         }
-        if (options.binary === true){
-            msg.expected = 'binary';
+        if (options.expect === 'base64' || options.expect === 'uint8'){
+            msg.expected = options.expect;
         }
         putData(msg, options.data);
         return new Promise(function (resolve, reject){
             msg.post().then(function (result){
                 let _result = { data: result.data };
-                _result.binary = result.binary ? true: false;
+                _result.format = result.format ? result.format : null;
                 if (result.hasOwnProperty('dec_info')){
                     _result.is_mime = result.dec_info.is_mime ? true: false;
                     if (result.dec_info.file_name) {
                         _result.file_name = result.dec_info.file_name;
                     }
                 }
                 if (!result.file_name) {
                     _result.file_name = null;
                 }
                 if (result.hasOwnProperty('info')
                     && result.info.hasOwnProperty('signatures')
                     && Array.isArray(result.info.signatures)
                 ) {
                     _result.signatures = collectSignatures(
                         result.info.signatures);
                 }
                 if (_result.signatures instanceof Error){
                     reject(_result.signatures);
                 } else {
                     resolve(_result);
                 }
             }, function (error){
                 reject(error);
             });
         });
     }
 
     /**
      * Sign a Message
      * @param {Object} options Signing options
      * @param {String|Object} options.data text/data to be signed. Accepts
      * Strings and Objects with a getText method.
      * @param {inputKeys} options.keys The key/keys to use for signing
      * @param {String} options.mode The signing mode. Currently supported:
      *  'clearsign':The Message is embedded into the signature;
      *  'detached': The signature is stored separately
      * @param {Boolean} options.base64 input is considered base64
      * @returns {Promise<signResult>}
      * @async
      */
     sign (options){
         if (
             !options || (typeof options !== 'object')){
             return Promise.reject(gpgme_error('PARAM_WRONG'));
         }
         if (!options.data){
             return Promise.reject(gpgme_error('MSG_EMPTY'));
         }
         if (!options.mode) {
             options.mode = 'clearsign';
         }
         let key_arr = toKeyIdArray(options.keys);
         if (key_arr.length === 0){
             return Promise.reject(gpgme_error('MSG_NO_KEYS'));
         }
         let msg = createMessage('sign');
 
         msg.setParameter('keys', key_arr);
         if (options.base64 === true){
             msg.setParameter('base64', true);
         }
         msg.setParameter('mode', options.mode);
         putData(msg, options.data);
         return new Promise(function (resolve,reject) {
             msg.post().then( function (message) {
                 if (options.mode === 'clearsign'){
                     resolve({
                         data: message.data }
                     );
                 } else if (options.mode === 'detached') {
                     resolve({
                         data: options.data,
                         signature: message.data
                     });
                 }
             }, function (error){
                 reject(error);
             });
         });
     }
 
     /**
      * Verifies data.
      * @param {Object} options
      * @param {String|Object} options.data text/data to be verified. Accepts
      * Strings and Objects with a getText method
      * @param {String} options.signature A detached signature. If not present,
      * opaque mode is assumed
      * @param {Boolean} options.base64 Indicating that data and signature are
      * base64 encoded
      * @returns {Promise<verifyResult>}
      *@async
     */
     verify (options){
         if (!options || (typeof options !== 'object') || !options.data){
             return Promise.reject(gpgme_error('PARAM_WRONG'));
         }
         let msg = createMessage('verify');
         let dt = putData(msg, options.data);
         if (dt instanceof Error){
             return Promise.reject(dt);
         }
         if (options.signature){
             if (typeof signature !== 'string'){
                 return Promise.reject(gpgme_error('PARAM_WRONG'));
             } else {
                 msg.setParameter('signature', signature);
             }
         }
         if (options.base64 === true){
             msg.setParameter('base64', true);
         }
         return new Promise(function (resolve, reject){
             msg.post().then(function (message){
                 if (!message.info || !message.info.signatures){
                     reject(gpgme_error('SIG_NO_SIGS'));
                 } else {
                     let _result = {
                         signatures: collectSignatures(message.info.signatures)
                     };
                     if (_result.signatures instanceof Error){
                         reject(_result.signatures);
                     } else {
                         _result.is_mime = message.info.is_mime? true: false;
                         if (message.info.filename){
                             _result.file_name = message.info.filename;
                         }
                         _result.data = message.data;
                         resolve(_result);
                     }
                 }
             }, function (error){
                 reject(error);
             });
         });
     }
 }
 
 /**
  * Sets the data of the message, setting flags according on the data type
  * @param {GPGME_Message} message The message where this data will be set
  * @param { String| Object } data The data to enter. Expects either a string of
  * data, or an object with a getText method
  * @returns {undefined| GPGME_Error} Error if not successful, nothing otherwise
  * @private
  */
 function putData (message, data){
     if (!message || !(message instanceof GPGME_Message)) {
         return gpgme_error('PARAM_WRONG');
     }
     if (!data){
         return gpgme_error('PARAM_WRONG');
     } else if (typeof data === 'string') {
         message.setParameter('data', data);
     } else if (
         (typeof data === 'object') &&
         (typeof data.getText === 'function')
     ){
         let txt = data.getText();
         if (typeof txt === 'string'){
             message.setParameter('data', txt);
         } else {
             return gpgme_error('PARAM_WRONG');
         }
 
     } else {
         return gpgme_error('PARAM_WRONG');
     }
 }
 
 /**
  * Parses, validates and converts incoming objects into signatures.
  * @param {Array<Object>} sigs
  * @returns {signatureDetails} Details about the signatures
  */
 function collectSignatures (sigs){
     if (!Array.isArray(sigs)){
         return gpgme_error('SIG_NO_SIGS');
     }
     let summary = {
         all_valid: false,
         count: sigs.length,
         failures: 0,
         signatures: {
             good: [],
             bad: [],
         }
     };
     for (let i=0; i< sigs.length; i++){
         let sigObj = createSignature(sigs[i]);
         if (sigObj instanceof Error) {
             return gpgme_error('SIG_WRONG');
         }
         if (sigObj.valid !== true){
             summary.failures += 1;
             summary.signatures.bad.push(sigObj);
         } else {
             summary.signatures.good.push(sigObj);
         }
     }
     if (summary.failures === 0){
         summary.all_valid = true;
     }
     return summary;
 }
\ No newline at end of file