@brickert/kerio-connect-api 0.0.7 → 0.0.9

package/index.d.ts

@@ -83,6 +83,7 @@ export interface GenericResponse {
             result?: Array;
             token?: string;
             detail?: string;
+            deleteItems?: number;
         }
     };
 }
@@ -109,6 +110,7 @@ export class Kerio extends WebClient {
     Logs: Logs;
     Domains: Domains;
     Users: Users;
+    MessageQueues: MessageQueues;
 
     login(user: KerioUser): void;
 
@@ -176,7 +178,7 @@ export class IPAddressGroup extends KerioModules {
      * Obtain a Mapped Array of IPAddressGroupItem indexed by their ID for the specified group name
      * @param group_name Name of the IPAddressGroup
      */
-    listIPAddressItemsByGroupName(group_name: string): Promise<Map<KerioIPAddressID, IPAddressGroupItem>>;
+    listByGroupName(group_name: string): Promise<Map<KerioIPAddressID, IPAddressGroupItem>>;
 
     /**
      * Add a IPAddressGroupItem of type 'host' of a single IP Address, with a specified description name, within a specified group name, and whether to have it enabled.
@@ -187,7 +189,7 @@ export class IPAddressGroup extends KerioModules {
      * @param enabled True to enable this host in the group
      * @returns Provides the unique KerioID of this host entry
      */
-    addHostToIPAddressGroup(host_ip: string, description: string, group_name: string, enabled: boolean): Promise<KerioIPAddressID>;
+    addHost(host_ip: string, description: string, group_name: string, enabled: boolean): Promise<KerioIPAddressID>;
 
     /**
      * Remove this IPAddressGroupItem of type 'host' of a single IP Address from this group name
@@ -195,7 +197,7 @@ export class IPAddressGroup extends KerioModules {
      * @param group_name Name of the IPAddressGroup string to remove this host in
      * @returns Returns True when removal was successful
      */
-    removeHostFromIPAddressGroupByIP(host_ip: string, group_name: string): Promise<boolean>;
+    removeHostByIP(host_ip: string, group_name: string): Promise<boolean>;
 
     /**
      * Remove IPAddressGroupItem(s) of type 'host' by the description name from this group name. TAKE CARE as this will remove all items upto the specified max limit that share the same name. You may limit number of items to remove. They are sorted by their unique ID.
@@ -204,8 +206,14 @@ export class IPAddressGroup extends KerioModules {
      * @param remove_limit Max number of group items to remove upto. Specifying -1 will remove ALL by the description name
      * @returns Returns an array of host IP addresses that were removed
      */
-    removeHostFromIPAddressGroupByDesc(description: string, group_name: string, remove_limit: number): Promise<Array<KerioIPAddressHost>>;
+    removeHostByDesc(description: string, group_name: string, remove_limit: number): Promise<Array<KerioIPAddressHost>>;
 
+    /**
+     * Remove IPAddressGroupItem by their unique ID
+     * @param KerioIPAddressID The unique ID for this entry obtained from Kerio.IPAddressGroup.listByGroupName
+     * @returns Returns True when removal was successful
+     */
+    removeHostByID(id: KerioIPAddressID): Promise<boolean>;
 }
 
 export type KerioIPAddressHost = string;
@@ -404,4 +412,100 @@ export interface KerioUserStatistic {
         xmpp: number;
         xmpps: number;
     }
-}
+}
+
+export class MessageQueues extends KerioModules {
+    /**
+     * Get a Mapped Array of KerioMessageItems indexed by their ID for messages that are pending to be processed
+     * @returns {Promise<Map<import('../index.d.ts').KerioMessageID, import('../index.d.ts').KerioMessageItem>>}
+     */
+    pending(): Promise<Map<KerioMessageID, KerioMessageItem>>;
+
+    /**
+     * Remove select message(s) that are held in queue/processing queue.
+     * @param messageId Single or Array of KerioMessageID(s)
+     * @returns {Promise<number>} Number of successfully removed messages
+     */
+    removeFromQueue(messageId: KerioMessageID | Array<KerioMessageID>): Promise<number>;
+
+    /**
+     * Remove all message(s) in the queue pending to be processed
+     * @returns {Promise<number>} Number of successfully removed messages
+     */
+    flushQueue(): Promise<number>;
+
+    /**
+     * Manually trigger sending these message(s) before their scheduled re-attempt
+     * @param messageId Single or Array of KerioMessageID(s)
+     * @returns {Promise<void>} Returns void. Access Kerio.MessageQueues.pending() to see any changes, messages not listed there are successfully being placed into the processed queue.
+     */
+    trySendingNow(messageId: KerioMessageID | Array<KerioMessageID>): Promise<void>;
+
+    /**
+     * Get a Mapped Array of KerioMessageItems indexed by their ID for a snapshot of the server's activity on processing messages
+     * @returns {Promise<Map<import('../index.d.ts').KerioMessageID, import('../index.d.ts').KerioMessageProcessedItem>>}
+     */
+    processing(): Promise<Map<KerioMessageID, KerioMessageProcessedItem>>;
+
+    /**
+     * Manually process message(s) now from their current stage.
+     * @returns {Promise<void>} Returns void. Access Kerio.MessageQueues.procesing() to see any changes, messages not listed there are successfully delivered to the destination server.
+     */
+    tryProcessingNow(): Promise<void>;
+}
+
+/**
+ * @example "1a2b3c4d-00000"
+ */
+export type KerioMessageID = string;
+
+export interface KerioMessageItem {
+    id: KerioMessageID;
+    status: string;
+    time: {
+        creationTime: string; //YYYY-MM-DD HH:MM of server's timezone
+        nextTry: string; //YYYY-MM-DD HH:MM of server's timezone
+    };
+    messageSize: {
+        value: number;
+        units: "Bytes"
+    };
+    headers: {
+        from: string;
+        to: string;
+    };
+    authSender: { 
+        address: string; //Authorized SMTP user email address
+        ip: string; //Authorized SMTP user ip address
+    }
+}
+
+export interface KerioMessageProcessedItem {
+    id: KerioMessageID;
+    status: {
+        progress: number; //Current progress in the current status stage
+        stage: KerioMessageProcessStatusEnum;
+        timeInCurrentStatus: string; //in HH:MM:SS format
+    };
+    messageSize: {
+        value: number;
+        units: "Bytes"
+    };
+    headers: {
+        from: string;
+        to: string;
+        destination: string; //Target SMTP server FQDN
+    };
+
+}
+
+/**
+ * msExecuting: General execution/starting state.
+ * msBackup: Message is being backed up.
+ * msContentFiltering: Passing through content/spam filters.
+ * msAntivirusControl: Being scanned for viruses.
+ * msLocalDelivering: Delivering to a mailbox on the local server.
+ * msSmtpDelivering: Attempting delivery to the next hop SMTP server.
+ * msFinishing: Finalizing the delivery/cleanup process.
+ */
+export type KerioMessageProcessStatusEnum = "msExecuting" | "msBackup" | "msContentFiltering" | "msAntivirusControl" | "msLocalDelivering" | "msSmtpDelivering" | "msFinishing";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brickert/kerio-connect-api",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "An unofficial API wrapper for Kerio Connect Mail Server jsonrpc Admin API.",
   "keywords": [
     "kerio",

package/src/ipaddressgroups.js

@@ -10,7 +10,7 @@ export class IPAddressGroup extends KerioModules {
      * @param {string} group_name Name of the IPAddressGroup these items are a member of
      * @returns {Promise<Map<import('../index.d.ts').KerioIPAddressID, import('../index.d.ts').IPAddressGroupItem>>}
      */
-    async listIPAddressItemsByGroupName(group_name = null) {
+    async listByGroupName(group_name = null) {
         try {
 
             if (!this.instance.logged_in) {
@@ -21,7 +21,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioClientSessionError",
                     message: `Kerio session invalid. Try logging in again.`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.listIPAddressItemsByGroupName"
+                    from: "Kerio.IPAddressGroups.listByGroupName"
                 }
             }
 
@@ -31,7 +31,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidIPAddressGroupNameError",
                     message: `Invalid referred Group Name while processing API method 'IPAddressGroups.get' for name '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.listIPAddressItemsByGroupName"
+                    from: "Kerio.IPAddressGroups.listByGroupName"
                 }
             }
 
@@ -85,7 +85,7 @@ export class IPAddressGroup extends KerioModules {
                         name: "KerioListIPAddressItems",
                         message: `listed ${ipAddresslist.size} items in IPAddressGroup '${group_name}'`,
                         type: 'Kerio',
-                        from: "Kerio.IPAddressGroups.listIPAddressItemsByGroupName"
+                        from: "Kerio.IPAddressGroups.listByGroupName"
                     });
 
                     return ipAddresslist;
@@ -98,7 +98,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioRequestError",
                     message: `Error occured while fetching results from API method 'IPAddressGroups.get' by name of '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.listIPAddressItemsByGroupName"
+                    from: "Kerio.IPAddressGroups.listByGroupName"
                 }
             }
 
@@ -116,7 +116,7 @@ export class IPAddressGroup extends KerioModules {
      * @param {boolean} enabled Enabled or disabled for this entry, defaults true
      * @returns {Promise<import('../index.d.ts').KerioIPAddressID>}
      */
-    async addHostToIPAddressGroup(host_ip, description = null, group_name = null, enabled = true) {
+    async addHost(host_ip, description = null, group_name = null, enabled = true) {
         try {
 
             if (!this.instance.logged_in) {
@@ -127,7 +127,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioClientSessionError",
                     message: `Kerio session invalid. Try logging in again.`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                    from: "Kerio.IPAddressGroups.addHost"
                 }
             }
 
@@ -136,7 +136,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidHostError",
                     message: `Invalid Host IP while processing API method 'IPAddressGroups.create' for host '${host_ip}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                    from: "Kerio.IPAddressGroups.addHost"
                 }
             }
 
@@ -145,7 +145,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidHostDescriptionError",
                     message: `Invalid Description for IPAddressEntry while processing API method 'IPAddressGroups.create' for host '${host_ip}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                    from: "Kerio.IPAddressGroups.addHost"
                 }
             }
 
@@ -154,7 +154,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidIPAddressGroupNameError",
                     message: `Invalid referred Group Name while processing API method 'IPAddressGroups.create' for host '${host_ip}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                    from: "Kerio.IPAddressGroups.addHost"
                 }
             }
 
@@ -163,7 +163,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidIPAddressEntryEnableError",
                     message: `Invalid Enabled value while processing API method 'IPAddressGroups.create' for host '${host_ip}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                    from: "Kerio.IPAddressGroups.addHost"
                 }
             }
 
@@ -195,7 +195,7 @@ export class IPAddressGroup extends KerioModules {
                         name: "KerioAddHostIPAddressGroup",
                         message: `Added host ${host_ip} with description ${description} in IPAddressGroup '${group_name}'`,
                         type: 'Kerio',
-                        from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                        from: "Kerio.IPAddressGroups.addHost"
                 });
 
                 return response_body.result.result[0].id;
@@ -207,21 +207,21 @@ export class IPAddressGroup extends KerioModules {
                             name: "KerioDuplicateError",
                             message: `Duplicate Host IP while processing API method 'IPAddressGroups.create' for host '${host_ip}' in group '${group_name}'`,
                             type: 'Kerio',
-                            from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                            from: "Kerio.IPAddressGroups.addHost"
                         }
                     case 1003:
                         throw {
                             name: "KerioInvalidHostError",
                             message: `Invalid Host IP while processing API method 'IPAddressGroups.create' for host '${host_ip}' in group '${group_name}'`,
                             type: 'Kerio',
-                            from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                            from: "Kerio.IPAddressGroups.addHost"
                         }
                     default:
                         throw {
                             name: "KerioRequestError",
                             message: `Error occured while fetching results from API method 'IPAddressGroups.create' for host '${host_ip}' in group '${group_name}'`,
                             type: 'Kerio',
-                            from: "Kerio.IPAddressGroups.addHostToIPAddressGroup"
+                            from: "Kerio.IPAddressGroups.addHost"
                         }
                 }
             }
@@ -238,7 +238,7 @@ export class IPAddressGroup extends KerioModules {
      * @param {string} group_name IPAddressGroup name this host is a member of
      * @returns {Promise<boolean>} Returns true when removal was successful
      */
-    async removeHostFromIPAddressGroupByIP(host_ip, group_name = null) {
+    async removeHostByIP(host_ip, group_name = null) {
         try {
 
             if (!this.instance.logged_in) {
@@ -249,7 +249,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioClientSessionError",
                     message: `Kerio session invalid. Try logging in again.`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                    from: "Kerio.IPAddressGroups.removeHostByIP"
                 }
             }
 
@@ -258,7 +258,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidHostError",
                     message: `Invalid Host IP while processing API method 'IPAddressGroups.remove' for host '${host_ip}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                    from: "Kerio.IPAddressGroups.removeHostByIP"
                 }
             }
 
@@ -267,11 +267,11 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidIPAddressGroupNameError",
                     message: `Invalid referred Group Name while processing API method 'IPAddressGroups.remove' for host '${host_ip}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                    from: "Kerio.IPAddressGroups.removeHostByIP"
                 }
             }
 
-            let get_host_ID_response = await this.listIPAddressItemsByGroupName(group_name);
+            let get_host_ID_response = await this.listByGroupName(group_name);
 
             if (get_host_ID_response.size != 0) {
                 
@@ -305,7 +305,7 @@ export class IPAddressGroup extends KerioModules {
                             name: "KerioRemoveHostIPAddressGroup",
                             message: `Removed host '${host_ip}' in group '${group_name}'`,
                             type: 'Kerio',
-                            from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                            from: "Kerio.IPAddressGroups.removeHostByIP"
                         });
 
                         return true;
@@ -317,21 +317,21 @@ export class IPAddressGroup extends KerioModules {
                                     name: "KerioHostRemoveError",
                                     message: `Host does not exist within group while fetching results from API method 'IPAddressGroups.remove' for host '${host_ip}' in group '${group_name}'`,
                                     type: 'Kerio',
-                                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                                    from: "Kerio.IPAddressGroups.removeHostByIP"
                                 }
                             case 1003:
                                 throw {
                                     name: "KerioHostRemoveError",
                                     message: `Host ID invalid while fetching results from API method 'IPAddressGroups.remove' for host '${host_ip}' in group '${group_name}'`,
                                     type: 'Kerio',
-                                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                                    from: "Kerio.IPAddressGroups.removeHostByIP"
                                 }
                             default:
                                 throw {
                                     name: "KerioRequestError",
                                     message: `Error occured while fetching results from API method 'IPAddressGroups.remove' for host '${host_ip}' in group '${group_name}'`,
                                     type: 'Kerio',
-                                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                                    from: "Kerio.IPAddressGroups.removeHostByIP"
                                 }
                         }
                     }
@@ -340,7 +340,7 @@ export class IPAddressGroup extends KerioModules {
                         name: "KerioHostNotExistError",
                         message: `Host IP does not exist in group while processing API method 'IPAddressGroups.remove' for host '${host_ip}' in group '${group_name}'`,
                         type: 'Kerio',
-                        from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                        from: "Kerio.IPAddressGroups.removeHostByIP"
                     }
                 }
             } else {
@@ -348,7 +348,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioHostNotExistGroupError",
                     message: `Group has no hosts while processing API method 'IPAddressGroups.remove' for host '${host_ip}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByIP"
+                    from: "Kerio.IPAddressGroups.removeHostByIP"
                 }
             }
 
@@ -365,7 +365,7 @@ export class IPAddressGroup extends KerioModules {
      * @param {number} remove_limit Max number of group items to remove upto. Specifying -1 will remove ALL by the description name
      * @returns Returns an array of host IP addresses that were removed
      */
-    async removeHostFromIPAddressGroupByDesc(description = null, group_name = null, remove_limit = 1) {
+    async removeHostByDesc(description = null, group_name = null, remove_limit = 1) {
         try {
 
             if (!this.instance.logged_in) {
@@ -376,7 +376,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioClientSessionError",
                     message: `Kerio session invalid. Try logging in again.`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                 }
             }
 
@@ -385,7 +385,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidGroupEntryRemoveLimitError",
                     message: `Invalid number of max host entries to remove while processing API method 'IPAddressGroups.remove' for description '${description}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                 }
             }
 
@@ -394,7 +394,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidGroupEntryDescriptionError",
                     message: `Invalid Description to search query while processing API method 'IPAddressGroups.remove' for description '${description}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                 }
             }
 
@@ -403,11 +403,11 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioInvalidIPAddressGroupNameError",
                     message: `Invalid referred Group Name while processing API method 'IPAddressGroups.remove' for description '${description}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                 }
             }
 
-            let get_host_ID_response = await this.listIPAddressItemsByGroupName(group_name);
+            let get_host_ID_response = await this.listByGroupName(group_name);
 
             if (get_host_ID_response.size != 0) {
                 
@@ -453,21 +453,21 @@ export class IPAddressGroup extends KerioModules {
                                     name: "KerioHostRemoveError",
                                     message: `Host does not exist within group while fetching results from API method 'IPAddressGroups.remove' in group '${group_name}'`,
                                     type: 'Kerio',
-                                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                                 }
                             case 1003:
                                 throw {
                                     name: "KerioHostRemoveError",
                                     message: `Host ID invalid while fetching results from API method 'IPAddressGroups.remove' in group '${group_name}'`,
                                     type: 'Kerio',
-                                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                                 }
                             default:
                                 throw {
                                     name: "KerioRequestError",
                                     message: `Error occured while fetching results from API method 'IPAddressGroups.remove' in group '${group_name}'`,
                                     type: 'Kerio',
-                                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                                 }
                         }
                     }
@@ -476,7 +476,7 @@ export class IPAddressGroup extends KerioModules {
                         name: "KerioDescriptionHostsNotExistError",
                         message: `Host ID(s) from specified description does not exist in group while processing API method 'IPAddressGroups.remove' for description '${description}' in group '${group_name}'`,
                         type: 'Kerio',
-                        from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                        from: "Kerio.IPAddressGroups.removeHostByDesc"
                     }
                 }
             } else {
@@ -484,7 +484,7 @@ export class IPAddressGroup extends KerioModules {
                     name: "KerioHostNotExistGroupError",
                     message: `Group has no hosts with the specified description while processing API method 'IPAddressGroups.remove' for description '${description}' in group '${group_name}'`,
                     type: 'Kerio',
-                    from: "Kerio.IPAddressGroups.removeHostFromIPAddressGroupByDesc"
+                    from: "Kerio.IPAddressGroups.removeHostByDesc"
                 }
             }
 
@@ -493,4 +493,84 @@ export class IPAddressGroup extends KerioModules {
             throw e;
         }
     }
+
+    /**
+     * Remove IPAddressGroupItem by their unique ID
+     * @param {string} id The unique ID for this entry obtained from Kerio.IPAddressGroup.listByGroupName
+     * @returns {Promise<boolean>} Returns True when removal was successful
+     */
+    async removeHostByID(id) {
+        try {
+
+            if (!this.instance.logged_in) {
+                
+                this.reset();
+
+                throw {
+                    name: "KerioClientSessionError",
+                    message: `Kerio session invalid. Try logging in again.`,
+                    type: 'Kerio',
+                    from: "Kerio.IPAddressGroups.removeHostByID"
+                }
+            }
+
+            if (!id) {
+                throw {
+                    name: "KerioInvalidIPAddressGroupItemIDError",
+                    message: `Invalid IPAddressGroupItem ID while processing API method 'IPAddressGroups.remove' for ID '${id}'`,
+                    type: 'Kerio',
+                    from: "Kerio.IPAddressGroups.removeHostByID"
+                }
+            }
+                
+            let remove_host_response = await this.sessionedRequest({
+                http_method: 'POST',
+                api_method: 'IpAddressGroups.remove',
+                auth: {
+                    cookie: this.instance.session_cookie,
+                    token: this.instance.x_token
+                },
+                body_params: {
+                    groupIds: [id]
+                }
+            });
+
+            let response_body = remove_host_response._body;
+
+            if (Array.isArray(response_body.result.errors) && response_body.result.errors.length == 0) {
+                        
+                this.instance.logger.info({
+                    name: "KerioRemoveHostIPAddressGroup",
+                    message: `Removed an IPAddressGroup entry of ID '${id}' successfully`,
+                    type: 'Kerio',
+                    from: "Kerio.IPAddressGroups.removeHostByID"
+                });
+
+                return true;
+
+            } else {
+                switch (response_body.result.errors[0]?.code) {
+                    case 1003:
+                        throw {
+                            name: "KerioHostRemoveError",
+                            message: `Host ID invalid while fetching results from API method 'IPAddressGroups.remove' for ID '${id}'`,
+                            type: 'Kerio',
+                            from: "Kerio.IPAddressGroups.removeHostByID"
+                        }
+                    default:
+                        throw {
+                            name: "KerioRequestError",
+                            message: `General error occured while fetching results from API method 'IPAddressGroups.remove' for ID '${id}'`,
+                            type: 'Kerio',
+                            from: "Kerio.IPAddressGroups.removeHostByID"
+                        }
+                }
+            }
+
+        } catch (e) {
+            this.instance.logger.error(e);
+            throw e;
+        }
+    }
+
 }

package/src/kerio.js

@@ -3,6 +3,7 @@ import { Logs } from "./logs.js";
 import { Session } from "./session.js";
 import { Domains } from "./domains.js";
 import { Users } from "./users.js";
+import { MessageQueues } from "./msgqueues.js";
 import { WebClient } from "./client.js";
 import { CronJob } from 'cron';
 import pino from 'pino';
@@ -27,6 +28,7 @@ export class Kerio extends WebClient {
         this.Session = new Session(this);
         this.Domains = new Domains(this);
         this.Users = new Users(this);
+        this.MessageQueues = new MessageQueues(this);
 
         this.logger = pino({
             level: "debug",

package/src/msgqueues.js

@@ -0,0 +1,469 @@
+import { KerioModules } from './modules.js';
+
+export class MessageQueues extends KerioModules {
+
+    /**
+     * Get a Mapped Array of KerioMessageItems indexed by their ID for messages that are pending to be processed
+     * @returns {Promise<Map<import('../index.d.ts').KerioMessageID, import('../index.d.ts').KerioMessageItem>>}
+     */
+    async pending() {
+        try {
+            if (!this.instance.logged_in) {
+
+                this.reset();
+
+                throw {
+                    name: "KerioClientSessionError",
+                    message: `Kerio session invalid. Try logging in again.`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.queued"
+                }
+            }
+
+            let queue_response = await this.sessionedRequest({
+                http_method: 'POST',
+                api_method: 'Queue.get',
+                auth: {
+                    cookie: this.instance.session_cookie,
+                    token: this.instance.x_token
+                },
+                body_params: {
+                    query: {
+                    }
+                }
+            });
+
+            let response_body = queue_response._body;
+
+            if (!response_body.result?.errors && !response_body?.error) {
+
+                var queueMsgsResult = new Map();
+
+                if (response_body.result.list.length > 0) {
+                    response_body.result.list.forEach(msg => {
+                        
+                        queueMsgsResult.set(msg.id, {
+                            id: msg.id,
+                            status: msg.status,
+                            time: {
+                                created: msg.creationTime,
+                                nextTry: msg.nextTry
+                            },
+                            messageSize: {
+                                value: msg.messageSize.value,
+                                units: msg.messageSize.units
+                            },
+                            headers: {
+                                from: msg.from,
+                                to: msg.to
+                            },
+                            authSender: {
+                                address: msg.authSender,
+                                ip: msg.senderIp
+                            }
+                        });
+                    });
+                }
+
+                this.instance.logger.debug({
+                    name: "KerioQueuedMessagesPending",
+                    message: `listed ${queueMsgsResult.size} queued messages pending to be processed`,
+                    type: "Kerio",
+                    from: "Kerio.MessageQueues.queued"
+                });
+
+                return queueMsgsResult;
+
+            } else {
+                throw {
+                    name: "KerioRequestError",
+                    message: `Error occured while fetching results from API method 'Queue.get'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.list"
+                }
+            }
+
+        } catch (e) {
+            this.instance.logger.error(e);
+            throw e;
+        }
+    }
+
+    /**
+     * Remove select message(s) that are held in the list of queue/processing queue.
+     * @param messageId Single or Array of KerioMessageID(s)
+     * @returns {Promise<number>} Number of successfully removed messages
+     */
+    async removeFromQueue(messageId = null) {
+        try {
+            if (!this.instance.logged_in) {
+
+                this.reset();
+
+                throw {
+                    name: "KerioClientSessionError",
+                    message: `Kerio session invalid. Try logging in again.`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.removeFromQueue"
+                }
+            }
+
+            if (!messageId || (Array.isArray(messageId) && messageId.length == 0)) {
+                throw {
+                    name: "KerioMessageIdError",
+                    message: `Invalid message ID or array of message IDs while processing API method 'Queue.remove'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.removeFromQueue"
+                }
+            }
+
+            //If single message ID string, convert to array of one element
+            if (!Array.isArray(messageId)) {
+                messageId = [messageId];
+            }
+
+            let queue_remove_response = await this.sessionedRequest({
+                http_method: 'POST',
+                api_method: 'Queue.remove',
+                auth: {
+                    cookie: this.instance.session_cookie,
+                    token: this.instance.x_token
+                },
+                body_params: {
+                    query: {
+                    },
+                    messageIds: messageId
+                }
+            });
+
+            let response_body = queue_remove_response._body;
+
+            if (!response_body.result?.errors && !response_body?.error) {
+
+                this.instance.logger.debug({
+                    name: "KerioQueuedMessagesRemoved",
+                    message: `Removed ${response_body.result.deleteItems} queued messages that were pending to be processed`,
+                    type: "Kerio",
+                    from: "Kerio.MessageQueues.removeFromQueue"
+                });
+
+                return response_body.result.deleteItems;
+
+            } else {
+                throw {
+                    name: "KerioRequestError",
+                    message: `Error occured while fetching results from API method 'Queue.remove'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.removeFromQueue"
+                }
+            }
+
+        } catch (e) {
+            this.instance.logger.error(e);
+            throw e;
+        }
+    }
+
+    /**
+     * Remove all message(s) in the queue pending to be processed
+     * @returns {Promise<number>} Number of successfully removed messages
+     */
+    async flushQueue() {
+        try {
+            if (!this.instance.logged_in) {
+
+                this.reset();
+
+                throw {
+                    name: "KerioClientSessionError",
+                    message: `Kerio session invalid. Try logging in again.`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.flushQueue"
+                }
+            }
+
+            let queue_response = await this.sessionedRequest({
+                http_method: 'POST',
+                api_method: 'Queue.removeAll',
+                auth: {
+                    cookie: this.instance.session_cookie,
+                    token: this.instance.x_token
+                },
+                body_params: {
+                    query: {
+                    }
+                }
+            });
+
+            let response_body = queue_response._body;
+
+            if (!response_body.result?.errors && !response_body?.error) {
+
+                this.instance.logger.debug({
+                    name: "KerioQueuedMessagesFlush",
+                    message: `Flushed ${response_body.result.deleteItems} queued messages pending to be processed`,
+                    type: "Kerio",
+                    from: "Kerio.MessageQueues.flushQueue"
+                });
+
+                return response_body.result.deleteItems;
+
+            } else {
+                throw {
+                    name: "KerioRequestError",
+                    message: `Error occured while fetching results from API method 'Queue.removeAll'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.flushQueue"
+                }
+            }
+
+        } catch (e) {
+            this.instance.logger.error(e);
+            throw e;
+        }
+    }
+
+    /**
+     * Manually trigger sending these message(s) before their scheduled re-attempt
+     * @param messageId Single or Array of KerioMessageID(s)
+     * @returns {Promise<void>} Returns void. Access Kerio.MessageQueues.queued() to see any changes, messages not listed there are successfully being placed into the processed queue.
+     */
+    async trySendingNow(messageId = null) {
+        try {
+            if (!this.instance.logged_in) {
+
+                this.reset();
+
+                throw {
+                    name: "KerioClientSessionError",
+                    message: `Kerio session invalid. Try logging in again.`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.trySendingNow"
+                }
+            }
+
+            if (!messageId || (Array.isArray(messageId) && messageId.length == 0)) {
+                throw {
+                    name: "KerioMessageIdError",
+                    message: `Invalid message ID or array of message IDs while processing API method 'Queue.tryToSend'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.trySendingNow"
+                }
+            }
+
+            //If single message ID string, convert to array of one element
+            if (!Array.isArray(messageId)) {
+                messageId = [messageId];
+            }
+
+            let try_sending_response = await this.sessionedRequest({
+                http_method: 'POST',
+                api_method: 'Queue.tryToSend',
+                auth: {
+                    cookie: this.instance.session_cookie,
+                    token: this.instance.x_token
+                },
+                body_params: {
+                    query: {
+                    },
+                    messageIds: messageId
+                }
+            });
+
+            let response_body = try_sending_response._body;
+
+            if (!response_body.result?.errors && !response_body?.error) {
+
+                let debug_msg = "";
+
+                if (Array.isArray(messageId)) {
+                    debug_msg = `Processing ${messageId.length} specified queued messages right now. Message IDs of '${messageId.join(', ')}'`;
+                } else {
+                    debug_msg = `Processing queued message right now. Message ID of '${messageId}'`;
+                }
+
+                this.instance.logger.debug({
+                    name: "KerioQueueTrySendingNowAttempt",
+                    message: debug_msg,
+                    type: "Kerio",
+                    from: "Kerio.MessageQueues.trySendingNow"
+                });
+
+                return;
+
+            } else {
+
+                if (response_body?.error?.code) {
+                    switch (response_body?.error?.code) {
+                        case 1000:
+                            // One or more Message Ids don't exist or already processed
+                            // Safe to silently error and return as you are intended to do Kerio.MessageQueues.pending() to check the status after.
+                            return;
+                        default:
+                            throw {
+                                name: "KerioRequestError",
+                                message: `Error occured while fetching results from API method 'Queue.tryToSend'`,
+                                type: 'Kerio',
+                                from: "Kerio.MessageQueues.trySendingNow"
+                            }
+                    }
+                }
+
+                throw {
+                    name: "KerioRequestError",
+                    message: `Error occured while fetching results from API method 'Queue.tryToSend'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.trySendingNow"
+                }
+            }
+
+        } catch (e) {
+            this.instance.logger.error(e);
+            throw e;
+        }
+    }
+
+    /**
+     * Get a Mapped Array of KerioMessageItems indexed by their ID for a snapshot of the server's activity on processing messages
+     * @returns {Promise<Map<import('../index.d.ts').KerioMessageID, import('../index.d.ts').KerioMessageProcessedItem>>}
+     */
+    async processing() {
+        try {
+            if (!this.instance.logged_in) {
+
+                this.reset();
+
+                throw {
+                    name: "KerioClientSessionError",
+                    message: `Kerio session invalid. Try logging in again.`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.processing"
+                }
+            }
+
+            let process_response = await this.sessionedRequest({
+                http_method: 'POST',
+                api_method: 'Queue.getProcessed',
+                auth: {
+                    cookie: this.instance.session_cookie,
+                    token: this.instance.x_token
+                },
+                body_params: {
+                    query: {
+                    }
+                }
+            });
+
+            let response_body = process_response._body;
+
+            if (!response_body.result?.errors && !response_body?.error) {
+
+                var processMsgsResult = new Map();
+
+                if (response_body.result.list.length > 0) {
+                    response_body.result.list.forEach(msg => {
+
+                        processMsgsResult.set(msg.id, {
+                            id: msg.id,
+                            status: {
+                                progress: msg.percentage,
+                                stage: msg.status,
+                                timeInCurrentStatus: msg.time
+                            },
+                            messageSize: {
+                                value: msg.messageSize.value,
+                                units: msg.messageSize.units
+                            },
+                            headers: {
+                                from: msg.from,
+                                to: msg.to,
+                                destination: msg.server
+                            }
+                        });
+                    });
+                }
+
+                this.instance.logger.debug({
+                    name: "KerioQueuedMessages",
+                    message: `listed ${processMsgsResult.size} processing messages`,
+                    type: "Kerio",
+                    from: "Kerio.MessageQueues.processing"
+                });
+
+                return processMsgsResult;
+
+            } else {
+                throw {
+                    name: "KerioRequestError",
+                    message: `Error occured while fetching results from API method 'Queue.get'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.list"
+                }
+            }
+
+        } catch (e) {
+            this.instance.logger.error(e);
+            throw e;
+        }
+    }
+
+    /**
+     * Manually process message(s) now from their current stage.
+     * @returns {Promise<void>} Returns void. Access Kerio.MessageQueues.procesing() to see any changes, messages not listed there are successfully delivered to the destination server.
+     */
+    async tryProcessingNow() {
+        try {
+            if (!this.instance.logged_in) {
+
+                this.reset();
+
+                throw {
+                    name: "KerioClientSessionError",
+                    message: `Kerio session invalid. Try logging in again.`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.tryProcessingNow"
+                }
+            }
+
+            let try_process_response = await this.sessionedRequest({
+                http_method: 'POST',
+                api_method: 'Queue.run',
+                auth: {
+                    cookie: this.instance.session_cookie,
+                    token: this.instance.x_token
+                },
+                body_params: {
+                    query: {
+                    }
+                }
+            });
+
+            let response_body = try_process_response._body;
+
+            if (!response_body.result?.errors && !response_body?.error) {
+
+                this.instance.logger.debug({
+                    name: "KerioQueueProcessingNow",
+                    message: `Force processing messages`,
+                    type: "Kerio",
+                    from: "Kerio.MessageQueues.tryProcessingNow"
+                });
+
+                return;
+
+            } else {
+                throw {
+                    name: "KerioRequestError",
+                    message: `Error occured while fetching results from API method 'Queue.run'`,
+                    type: 'Kerio',
+                    from: "Kerio.MessageQueues.tryProcessingNow"
+                }
+            }
+
+        } catch (e) {
+            this.instance.logger.error(e);
+            throw e;
+        }
+    }
+
+}