@didcid/keymaster 0.1.3

package/dist/cjs/keymaster-client.cjs

@@ -0,0 +1,1139 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var buffer = require('buffer');
+var axiosModule = require('axios');
+
+const axios = axiosModule?.default ??
+    axiosModule;
+const VERSION = '/api/v1';
+function throwError(error) {
+    if (error.response) {
+        throw error.response.data;
+    }
+    throw error;
+}
+class KeymasterClient {
+    API = "/api/v1";
+    // Factory method
+    static async create(options) {
+        const keymaster = new KeymasterClient();
+        await keymaster.connect(options);
+        return keymaster;
+    }
+    async connect(options = {}) {
+        if (options.url) {
+            this.API = `${options.url}${VERSION}`;
+        }
+        // Only used for unit testing
+        // TBD replace console with a real logging package
+        if (options.console) {
+            // eslint-disable-next-line
+            console = options.console;
+        }
+        if (options.waitUntilReady) {
+            await this.waitUntilReady(options);
+        }
+    }
+    async waitUntilReady(options = {}) {
+        let { intervalSeconds = 5, chatty = false, becomeChattyAfter = 0, maxRetries = 0 } = options;
+        let ready = false;
+        let retries = 0;
+        if (chatty) {
+            console.log(`Connecting to Keymaster at ${this.API}`);
+        }
+        while (!ready) {
+            ready = await this.isReady();
+            if (!ready) {
+                if (chatty) {
+                    console.log('Waiting for Keymaster to be ready...');
+                }
+                // wait for 1 second before checking again
+                await new Promise(resolve => setTimeout(resolve, intervalSeconds * 1000));
+            }
+            retries += 1;
+            if (maxRetries > 0 && retries > maxRetries) {
+                return;
+            }
+            if (!chatty && becomeChattyAfter > 0 && retries > becomeChattyAfter) {
+                console.log(`Connecting to Keymaster at ${this.API}`);
+                chatty = true;
+            }
+        }
+        if (chatty) {
+            console.log('Keymaster service is ready!');
+        }
+    }
+    async isReady() {
+        try {
+            const response = await axios.get(`${this.API}/ready`);
+            return response.data.ready;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async loadWallet() {
+        try {
+            const response = await axios.get(`${this.API}/wallet`);
+            return response.data.wallet;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async saveWallet(wallet) {
+        try {
+            const response = await axios.put(`${this.API}/wallet`, { wallet });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async newWallet(mnemonic, overwrite = false) {
+        try {
+            const response = await axios.post(`${this.API}/wallet/new`, { mnemonic, overwrite });
+            return response.data.wallet;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async backupWallet() {
+        try {
+            const response = await axios.post(`${this.API}/wallet/backup`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async recoverWallet() {
+        try {
+            const response = await axios.post(`${this.API}/wallet/recover`);
+            return response.data.wallet;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async checkWallet() {
+        try {
+            const response = await axios.post(`${this.API}/wallet/check`);
+            return response.data.check;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async fixWallet() {
+        try {
+            const response = await axios.post(`${this.API}/wallet/fix`);
+            return response.data.fix;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async decryptMnemonic() {
+        try {
+            const response = await axios.get(`${this.API}/wallet/mnemonic`);
+            return response.data.mnemonic;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listRegistries() {
+        try {
+            const response = await axios.get(`${this.API}/registries`);
+            return response.data.registries;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getCurrentId() {
+        try {
+            const response = await axios.get(`${this.API}/ids/current`);
+            return response.data.current;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async setCurrentId(name) {
+        try {
+            const response = await axios.put(`${this.API}/ids/current`, { name });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listIds() {
+        try {
+            const response = await axios.get(`${this.API}/ids`);
+            return response.data.ids;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async rotateKeys() {
+        try {
+            const response = await axios.post(`${this.API}/keys/rotate`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async encryptMessage(msg, receiver, options = {}) {
+        try {
+            const response = await axios.post(`${this.API}/keys/encrypt/message`, { msg, receiver, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async decryptMessage(did) {
+        try {
+            const response = await axios.post(`${this.API}/keys/decrypt/message`, { did });
+            return response.data.message;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async encryptJSON(json, receiver, options) {
+        try {
+            const response = await axios.post(`${this.API}/keys/encrypt/json`, { json, receiver, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async decryptJSON(did) {
+        try {
+            const response = await axios.post(`${this.API}/keys/decrypt/json`, { did });
+            return response.data.json;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createId(name, options) {
+        try {
+            const response = await axios.post(`${this.API}/ids`, { name, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeId(id) {
+        try {
+            const response = await axios.delete(`${this.API}/ids/${id}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async renameId(id, name) {
+        try {
+            const response = await axios.post(`${this.API}/ids/${id}/rename`, { name });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async backupId(id) {
+        try {
+            if (!id) {
+                id = await this.getCurrentId();
+            }
+            const response = await axios.post(`${this.API}/ids/${id}/backup`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async recoverId(did) {
+        try {
+            const response = await axios.post(`${this.API}/ids/${did}/recover`);
+            return response.data.recovered;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listNames() {
+        try {
+            const response = await axios.get(`${this.API}/names`);
+            return response.data.names;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addName(name, did) {
+        try {
+            const response = await axios.post(`${this.API}/names`, { name, did });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getName(name) {
+        try {
+            const response = await axios.get(`${this.API}/names/${name}`);
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeName(name) {
+        try {
+            const response = await axios.delete(`${this.API}/names/${name}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async resolveDID(id, options) {
+        try {
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                const response = await axios.get(`${this.API}/did/${id}?${queryParams.toString()}`);
+                return response.data.docs;
+            }
+            else {
+                const response = await axios.get(`${this.API}/did/${id}`);
+                return response.data.docs;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async revokeDID(id) {
+        try {
+            const response = await axios.delete(`${this.API}/did/${id}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createAsset(data, options) {
+        try {
+            const response = await axios.post(`${this.API}/assets`, { data, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async cloneAsset(id, options) {
+        try {
+            const response = await axios.post(`${this.API}/assets/${id}/clone`, { options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listAssets() {
+        try {
+            const response = await axios.get(`${this.API}/assets`);
+            return response.data.assets;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async resolveAsset(id, options) {
+        try {
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                const response = await axios.get(`${this.API}/assets/${id}?${queryParams.toString()}`);
+                return response.data.asset;
+            }
+            else {
+                const response = await axios.get(`${this.API}/assets/${id}`);
+                return response.data.asset;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async updateAsset(id, data) {
+        try {
+            const response = await axios.put(`${this.API}/assets/${id}`, { data });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async transferAsset(id, controller) {
+        try {
+            const response = await axios.post(`${this.API}/assets/${id}/transfer`, { controller });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createChallenge(challenge = {}, options = {}) {
+        try {
+            const response = await axios.post(`${this.API}/challenge`, { challenge, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createResponse(challenge, options) {
+        try {
+            const response = await axios.post(`${this.API}/response`, { challenge, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async verifyResponse(responseDID, options) {
+        try {
+            const response = await axios.post(`${this.API}/response/verify`, { response: responseDID, options });
+            return response.data.verify;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createGroup(name, options) {
+        try {
+            const response = await axios.post(`${this.API}/groups`, { name, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getGroup(group) {
+        try {
+            const response = await axios.get(`${this.API}/groups/${group}`);
+            return response.data.group;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addGroupMember(group, member) {
+        try {
+            const response = await axios.post(`${this.API}/groups/${group}/add`, { member });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeGroupMember(group, member) {
+        try {
+            const response = await axios.post(`${this.API}/groups/${group}/remove`, { member });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async testGroup(group, member) {
+        try {
+            const response = await axios.post(`${this.API}/groups/${group}/test`, { member });
+            return response.data.test;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listGroups(owner) {
+        try {
+            if (owner) {
+                const response = await axios.get(`${this.API}/groups?owner=${owner}`);
+                return response.data.groups;
+            }
+            else {
+                const response = await axios.get(`${this.API}/groups`);
+                return response.data.groups;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createSchema(schema, options) {
+        try {
+            const response = await axios.post(`${this.API}/schemas`, { schema, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getSchema(id) {
+        try {
+            const response = await axios.get(`${this.API}/schemas/${id}`);
+            return response.data.schema;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async setSchema(id, schema) {
+        try {
+            const response = await axios.put(`${this.API}/schemas/${id}`, { schema });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async testSchema(id) {
+        try {
+            const response = await axios.post(`${this.API}/schemas/${id}/test`);
+            return response.data.test;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listSchemas(owner) {
+        try {
+            if (owner) {
+                const response = await axios.get(`${this.API}/schemas?owner=${owner}`);
+                return response.data.schemas;
+            }
+            else {
+                const response = await axios.get(`${this.API}/schemas`);
+                return response.data.schemas;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createTemplate(schemaId) {
+        try {
+            const response = await axios.post(`${this.API}/schemas/${schemaId}/template`);
+            return response.data.template;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async testAgent(id) {
+        try {
+            const response = await axios.post(`${this.API}/agents/${id}/test`);
+            return response.data.test;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async bindCredential(schema, subject, options) {
+        try {
+            const response = await axios.post(`${this.API}/credentials/bind`, { schema, subject, options });
+            return response.data.credential;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async issueCredential(credential, options) {
+        try {
+            const response = await axios.post(`${this.API}/credentials/issued`, { credential, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async sendCredential(did, options) {
+        try {
+            const response = await axios.post(`${this.API}/credentials/issued/${did}/send`, { options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async updateCredential(did, credential) {
+        try {
+            const response = await axios.post(`${this.API}/credentials/issued/${did}`, { credential });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listCredentials() {
+        try {
+            const response = await axios.get(`${this.API}/credentials/held`);
+            return response.data.held;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async acceptCredential(did) {
+        try {
+            const response = await axios.post(`${this.API}/credentials/held`, { did });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getCredential(did) {
+        try {
+            const response = await axios.get(`${this.API}/credentials/held/${did}`);
+            return response.data.credential;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeCredential(did) {
+        try {
+            const response = await axios.delete(`${this.API}/credentials/held/${did}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async publishCredential(did, options) {
+        try {
+            const response = await axios.post(`${this.API}/credentials/held/${did}/publish`, { options });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async unpublishCredential(did) {
+        try {
+            const response = await axios.post(`${this.API}/credentials/held/${did}/unpublish`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listIssued() {
+        try {
+            const response = await axios.get(`${this.API}/credentials/issued`);
+            return response.data.issued;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async revokeCredential(did) {
+        try {
+            const response = await axios.delete(`${this.API}/credentials/issued/${did}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async pollTemplate() {
+        try {
+            const response = await axios.get(`${this.API}/templates/poll`);
+            return response.data.template;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createPoll(poll, options) {
+        try {
+            const response = await axios.post(`${this.API}/polls`, { poll, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getPoll(pollId) {
+        try {
+            const response = await axios.get(`${this.API}/polls/${pollId}`);
+            return response.data.poll;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async viewPoll(pollId) {
+        try {
+            const response = await axios.get(`${this.API}/polls/${pollId}/view`);
+            return response.data.poll;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async votePoll(pollId, vote, options) {
+        try {
+            const response = await axios.post(`${this.API}/polls/${pollId}/vote`, { vote, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async updatePoll(ballot) {
+        try {
+            const response = await axios.put(`${this.API}/polls/update`, { ballot });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async publishPoll(pollId, options) {
+        try {
+            const response = await axios.post(`${this.API}/polls/${pollId}/publish`, { options });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async unpublishPoll(pollId) {
+        try {
+            const response = await axios.post(`${this.API}/polls/${pollId}/unpublish`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createImage(data, options = {}) {
+        try {
+            const response = await axios.post(`${this.API}/images`, data, {
+                headers: {
+                    // eslint-disable-next-line
+                    'Content-Type': 'application/octet-stream',
+                    'X-Options': JSON.stringify(options), // Pass options as a custom header
+                }
+            });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async updateImage(id, data) {
+        try {
+            const response = await axios.put(`${this.API}/images/${id}`, data, {
+                headers: {
+                    'Content-Type': 'application/octet-stream'
+                }
+            });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getImage(id) {
+        try {
+            const response = await axios.get(`${this.API}/images/${id}`);
+            return response.data.image;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async testImage(id) {
+        try {
+            const response = await axios.post(`${this.API}/images/${id}/test`);
+            return response.data.test;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createDocument(data, options = {}) {
+        try {
+            const response = await axios.post(`${this.API}/documents`, data, {
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    'X-Options': JSON.stringify(options), // Pass options as a custom header
+                }
+            });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async updateDocument(id, data, options = {}) {
+        try {
+            const response = await axios.put(`${this.API}/documents/${id}`, data, {
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    'X-Options': JSON.stringify(options), // Pass options as a custom header
+                }
+            });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getDocument(id) {
+        try {
+            const response = await axios.get(`${this.API}/documents/${id}`);
+            return response.data.document;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async testDocument(id) {
+        try {
+            const response = await axios.post(`${this.API}/documents/${id}/test`);
+            return response.data.test;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createGroupVault(options = {}) {
+        try {
+            const response = await axios.post(`${this.API}/groupVaults`, { options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getGroupVault(id, options) {
+        try {
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                const response = await axios.get(`${this.API}/groupVaults/${id}?${queryParams.toString()}`);
+                return response.data.groupVault;
+            }
+            else {
+                const response = await axios.get(`${this.API}/groupVaults/${id}`);
+                return response.data.groupVault;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async testGroupVault(id, options) {
+        try {
+            const response = await axios.post(`${this.API}/groupVaults/${id}/test`, { options });
+            return response.data.test;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addGroupVaultMember(vaultId, memberId) {
+        try {
+            const response = await axios.post(`${this.API}/groupVaults/${vaultId}/members`, { memberId });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeGroupVaultMember(vaultId, memberId) {
+        try {
+            const response = await axios.delete(`${this.API}/groupVaults/${vaultId}/members/${memberId}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listGroupVaultMembers(vaultId) {
+        try {
+            const response = await axios.get(`${this.API}/groupVaults/${vaultId}/members`);
+            return response.data.members;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addGroupVaultItem(vaultId, name, buffer) {
+        try {
+            const response = await axios.post(`${this.API}/groupVaults/${vaultId}/items`, buffer, {
+                headers: {
+                    // eslint-disable-next-line
+                    'Content-Type': 'application/octet-stream',
+                    'X-Options': JSON.stringify({ name }), // Pass name as a custom header
+                }
+            });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeGroupVaultItem(vaultId, name) {
+        try {
+            const response = await axios.delete(`${this.API}/groupVaults/${vaultId}/items/${name}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listGroupVaultItems(vaultId, options) {
+        try {
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                const response = await axios.get(`${this.API}/groupVaults/${vaultId}/items?${queryParams.toString()}`);
+                return response.data.items;
+            }
+            else {
+                const response = await axios.get(`${this.API}/groupVaults/${vaultId}/items`);
+                return response.data.items;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getGroupVaultItem(vaultId, name, options) {
+        try {
+            let url = `${this.API}/groupVaults/${vaultId}/items/${name}`;
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                url += `?${queryParams.toString()}`;
+            }
+            const response = await axios.get(url, {
+                responseType: 'arraybuffer'
+            });
+            if (!response.data || (buffer.Buffer.isBuffer(response.data) && response.data.length === 0)) {
+                return null;
+            }
+            return buffer.Buffer.from(response.data);
+        }
+        catch (error) {
+            const axiosError = error;
+            // Return null for 404 Not Found
+            if (axiosError.response && axiosError.response.status === 404) {
+                return null;
+            }
+            if (axiosError.response && axiosError.response.data instanceof Uint8Array) {
+                const textDecoder = new TextDecoder();
+                const errorMessage = textDecoder.decode(axiosError.response.data);
+                axiosError.response.data = JSON.parse(errorMessage);
+            }
+            throwError(axiosError);
+        }
+    }
+    async listDmail() {
+        try {
+            const response = await axios.get(`${this.API}/dmail`);
+            return response.data.dmail;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createDmail(message, options = {}) {
+        try {
+            const response = await axios.post(`${this.API}/dmail`, { message, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async updateDmail(did, message) {
+        try {
+            const response = await axios.put(`${this.API}/dmail/${did}`, { message });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async sendDmail(did) {
+        try {
+            const response = await axios.post(`${this.API}/dmail/${did}/send`);
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async fileDmail(did, tags) {
+        try {
+            const response = await axios.post(`${this.API}/dmail/${did}/file`, { tags });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeDmail(did) {
+        try {
+            const response = await axios.delete(`${this.API}/dmail/${did}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getDmailMessage(did, options) {
+        try {
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                const response = await axios.get(`${this.API}/dmail/${did}?${queryParams.toString()}`);
+                return response.data.message;
+            }
+            else {
+                const response = await axios.get(`${this.API}/dmail/${did}`);
+                return response.data.message;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async listDmailAttachments(did, options) {
+        try {
+            if (options) {
+                const queryParams = new URLSearchParams(options);
+                const response = await axios.get(`${this.API}/dmail/${did}/attachments?${queryParams.toString()}`);
+                return response.data.attachments;
+            }
+            else {
+                const response = await axios.get(`${this.API}/dmail/${did}/attachments`);
+                return response.data.attachments;
+            }
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async addDmailAttachment(did, name, buffer) {
+        try {
+            const response = await axios.post(`${this.API}/dmail/${did}/attachments`, buffer, {
+                headers: {
+                    // eslint-disable-next-line
+                    'Content-Type': 'application/octet-stream',
+                    'X-Options': JSON.stringify({ name }), // Pass name as a custom header
+                }
+            });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async removeDmailAttachment(did, name) {
+        try {
+            const response = await axios.delete(`${this.API}/dmail/${did}/attachments/${name}`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async getDmailAttachment(did, name) {
+        try {
+            const response = await axios.get(`${this.API}/dmail/${did}/attachments/${name}`, {
+                responseType: 'arraybuffer'
+            });
+            if (!response.data || (buffer.Buffer.isBuffer(response.data) && response.data.length === 0)) {
+                return null;
+            }
+            return buffer.Buffer.from(response.data);
+        }
+        catch (error) {
+            const axiosError = error;
+            // Return null for 404 Not Found
+            if (axiosError.response && axiosError.response.status === 404) {
+                return null;
+            }
+            if (axiosError.response && axiosError.response.data instanceof Uint8Array) {
+                const textDecoder = new TextDecoder();
+                const errorMessage = textDecoder.decode(axiosError.response.data);
+                axiosError.response.data = JSON.parse(errorMessage);
+            }
+            throwError(axiosError);
+        }
+    }
+    async importDmail(did) {
+        try {
+            const response = await axios.post(`${this.API}/dmail/import`, { did });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async createNotice(message, options = {}) {
+        try {
+            const response = await axios.post(`${this.API}/notices`, { message, options });
+            return response.data.did;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async updateNotice(did, message) {
+        try {
+            const response = await axios.put(`${this.API}/notices/${did}`, { message });
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async refreshNotices() {
+        try {
+            const response = await axios.post(`${this.API}/notices/refresh`);
+            return response.data.ok;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+    async exportEncryptedWallet() {
+        try {
+            const response = await axios.get(`${this.API}/export/wallet/encrypted`);
+            return response.data.wallet;
+        }
+        catch (error) {
+            throwError(error);
+        }
+    }
+}
+
+exports.default = KeymasterClient;