denotify-client 1.1.4 → 1.1.5

package/dist/alertbuilder.js

@@ -1,3 +1,7 @@
+import { NotifyDiscordWebhook } from "./notifications/notify_discord_webhook.js";
+import { HandlerFunctionCall } from "./triggers/handler_function_call.js";
+import { HandlerFunctionCallV2 } from "./triggers/handler_function_call_v2.js";
+import { HandlerOnchainEvent } from "./triggers/handler_onchain_event.js";
 export class AlertBuilder {
     name;
     network;
@@ -15,6 +19,13 @@ export class AlertBuilder {
         this.network = network;
         return this;
     }
+    /**
+     * Call withTrigger with one of the TriggerConfig types:
+     * PollFunctionV2 | PollFunctionV1 | OnchainEventV1
+     * @param id Simple ID
+     * @param options Desired trigger configuration
+     * @returns self for piping
+     */
     withTrigger(id, options) {
         this.triggerId = id;
         this.trigger = options;
@@ -25,13 +36,25 @@ export class AlertBuilder {
         this.notification = options;
         return this;
     }
-    config() {
+    async validate() {
+        // Validate trigger
+        switch (this.triggerId) {
+            case 'OnchainEventV1': return HandlerOnchainEvent.validateCreate(this.trigger);
+            case 'PollFunctionV1': return HandlerFunctionCall.validateCreate(this.trigger);
+            case 'PollFunctionV2': return HandlerFunctionCallV2.validateCreate(this.trigger);
+        }
+        switch (this.notificationId) {
+            case 'Discord': return NotifyDiscordWebhook.validateCreate(this.notification);
+        }
+    }
+    async config() {
         if (this.trigger === undefined || this.triggerId === undefined)
             throw new Error('Trigger not configured');
         if (this.notification === undefined || this.notificationId === undefined)
             throw new Error('Notification not configured');
         if (this.network === undefined)
             throw new Error('Network not configured');
+        await this.validate();
         return {
             name: this.name,
             network: this.network,

package/dist/examples/balance-monitor.js

@@ -0,0 +1,47 @@
+import { AlertBuilder } from "../alertbuilder.js";
+import { DeNotifyClient } from "../denotifyclient.js";
+import { FunctionBuilder } from "../functionbuilder.js";
+import { FilterBuilder } from "../util/filter.js";
+// Simple App to demonstrate usage. Created a balance monitoring alert, updates it and deletes it
+async function main() {
+    const api = await DeNotifyClient.create({
+        email: process.env.EMAIL,
+        password: process.env.PASSWORD,
+    });
+    const network = 'avalanche';
+    const address = '0x26985888d5b7019ff2A7444fB567D8F386c3b538';
+    const myAddress = '0x7601630eC802952ba1ED2B6e4db16F699A0a5A87';
+    const { abi } = await api.getAbi(network, address);
+    const webhook = process.env.DISCORD_WEBHOOK;
+    const builder = FunctionBuilder.create(api);
+    await builder.addFunction(address, 'getBalance', [myAddress], abi);
+    // Create the Balance Monitor alert
+    const alert = await AlertBuilder.create('Test Alert')
+        .onNetwork('avalanche')
+        .withTrigger('PollFunctionV2', {
+        timeBase: 'time',
+        timePeriod: '100s',
+        functions: builder.get(),
+        triggerOn: 'always',
+    })
+        .withNotification('Discord', {
+        url: webhook,
+        message: `Your avax balance is [{func_0_ret_0 / 1e18}](https://snowtrace.io/address/${myAddress})`,
+    })
+        .config();
+    // Create the alert with the API
+    const triggerId = await api.createAlert(alert);
+    console.log(triggerId);
+    // Update the period to every 10s
+    await api.updateTrigger(triggerId, { timePeriod: '10s' });
+    // Update the Filter using the filter builder
+    const filter = FilterBuilder.new()
+        .addCondition('WHERE', 'func_0_ret_0', 'Number', 'gt', 3)
+        .finalise();
+    await api.updateTrigger(13, { triggerOn: 'filter', filter, filterVersion: FilterBuilder.version() });
+    // Delete the filter in 10s
+    setTimeout(async () => {
+        await api.deleteAlert(triggerId);
+    }, 10 * 1000);
+}
+main();

package/dist/functionbuilder.js

@@ -1,4 +1,5 @@
 import { ethers } from "ethers";
+import * as yup from 'yup';
 export class FunctionBuilder {
     api;
     data = [];
@@ -27,4 +28,12 @@ export class FunctionBuilder {
     get() {
         return this.data;
     }
+    static schema() {
+        return yup.array().of(yup.object({
+            address: yup.string().required(),
+            bytecode: yup.string().matches(/^(0x)?([0-9a-fA-F]{2})*$/).required(),
+            abiHash: yup.string().matches(/^[A-Fa-f0-9]{64}/).required(),
+            function: yup.string().required()
+        }));
+    }
 }

package/dist/index.js

@@ -11,10 +11,29 @@ var followRedirects = require('follow-redirects');
 var zlib = require('zlib');
 var stream = require('stream');
 var EventEmitter = require('events');
+var yup = require('yup');
 var ethers = require('ethers');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 var FormData__default = /*#__PURE__*/_interopDefaultLegacy(FormData$1);
 var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
 var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
@@ -24,6 +43,7 @@ var followRedirects__default = /*#__PURE__*/_interopDefaultLegacy(followRedirect
 var zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib);
 var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream);
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+var yup__namespace = /*#__PURE__*/_interopNamespace(yup);
 
 function bind(fn, thisArg) {
   return function wrap() {
@@ -4075,6 +4095,16 @@ class NotifyDiscordWebhook {
             notify: config
         };
     }
+    static validateCreate(options) {
+        const urlRegex = /^(https?|ftp):\/\/(-\.)?([^\s/?\.#]+\.?)+([^\s\.?#]+)?(\?\S*)?$/;
+        const schema = yup__namespace.object({
+            url: yup__namespace.string().matches(urlRegex, 'url is not a valid url').required(),
+            username: yup__namespace.string(),
+            avatar_url: yup__namespace.string().matches(urlRegex, 'url is not a valid url'),
+            message: yup__namespace.string().required()
+        });
+        return schema.validate(options);
+    }
 }
 
 class Notification {
@@ -4096,6 +4126,19 @@ class HandlerFunctionCall {
             handler: config
         };
     }
+    static validateCreate(options) {
+        const requiredWhenConditional = ([condition], schema) => condition === 'true' ? schema.notRequired() : schema.required();
+        const schema = yup__namespace.object({
+            address: yup__namespace.string().required(),
+            abi: yup__namespace.array().required(),
+            nBlocks: yup__namespace.number().min(10),
+            condition: yup__namespace.string().oneOf(['>', '>=', '<', '<=', '=', 'true']),
+            constant: yup__namespace.number().min(0).when('condition', requiredWhenConditional),
+            responseArgIndex: yup__namespace.number().min(0).when('condition', requiredWhenConditional),
+            responseArgDecimals: yup__namespace.number().min(0).when('condition', requiredWhenConditional),
+        });
+        return schema.validate(options);
+    }
 }
 
 const HANDLER_ONCHAIN_EVENT_V1_RAW_ID = 'handler_onchain_event';
@@ -4109,6 +4152,219 @@ class HandlerOnchainEvent {
             handler: config
         };
     }
+    static validateCreate(options) {
+        const requiredWhenConditional = ([condition], schema) => condition === 'true' ? schema.notRequired() : schema.required();
+        const onchainEventSchema = yup__namespace.object({
+            address: yup__namespace.string().required(),
+            event: yup__namespace.string().required(),
+            abi: yup__namespace.array().required(),
+            condition: yup__namespace.string().oneOf(['>', '>=', '<', '<=', '=', 'true']),
+            constant: yup__namespace.number().min(0).when('condition', requiredWhenConditional),
+            paramsIndex: yup__namespace.number().min(0).when('condition', requiredWhenConditional),
+            paramsDecimals: yup__namespace.number().min(0).when('condition', requiredWhenConditional),
+        });
+        return onchainEventSchema.validate(options);
+    }
+    static validateUpdate(options) {
+    }
+}
+
+class FunctionBuilder {
+    api;
+    data = [];
+    constructor(api) {
+        this.api = api;
+    }
+    static create(api) {
+        return new FunctionBuilder(api);
+    }
+    getAbiHash(abi) {
+        if (this.api === undefined)
+            throw new Error('FunctionBuilder must be initialised with api');
+        return this.api.getAbiHash(abi);
+    }
+    async addFunction(address, func, args, abi) {
+        const contract = new ethers.ethers.Contract(address, abi);
+        contract.interface.encodeFunctionData(func, args);
+        this.data.push({
+            address,
+            bytecode: contract.interface.encodeFunctionData(func, args),
+            abiHash: await this.getAbiHash(abi),
+            function: func,
+        });
+        return this;
+    }
+    get() {
+        return this.data;
+    }
+    static schema() {
+        return yup__namespace.array().of(yup__namespace.object({
+            address: yup__namespace.string().required(),
+            bytecode: yup__namespace.string().matches(/^(0x)?([0-9a-fA-F]{2})*$/).required(),
+            abiHash: yup__namespace.string().matches(/^[A-Fa-f0-9]{64}/).required(),
+            function: yup__namespace.string().required()
+        }));
+    }
+}
+
+class Filter {
+    static version() {
+        return 'v1';
+    }
+    static execute(record, groupsIn, version = 'v1') {
+        // Deep copy to so we can edit the object during recursion
+        const groups = JSON.parse(JSON.stringify(groupsIn));
+        let lhs = true;
+        for (const group of groups) {
+            const rhs = Filter.process(record, group.conditions);
+            lhs = Filter.execLogic(lhs, group.logic, rhs);
+        }
+        return lhs;
+    }
+    static process(record, conditions, lhs) {
+        const condition = conditions.shift();
+        if (!condition) {
+            if (lhs === undefined)
+                return true;
+            return lhs;
+        }
+        // lhs <logic> rhs
+        const rhs = Filter.execCondition(record, condition);
+        if (lhs === undefined || condition.logic === 'WHERE')
+            return Filter.process(record, conditions, rhs);
+        if (condition.logic === undefined)
+            throw new Error('Invalid filter. Condition must have logic value');
+        const next = Filter.execLogic(lhs, condition.logic, rhs);
+        return Filter.process(record, conditions, next);
+    }
+    static execLogic(lhs, logic, rhs) {
+        switch (logic) {
+            case 'AND': return lhs && rhs;
+            case 'OR': return lhs || rhs;
+            case 'XOR': return (lhs || rhs) && !(lhs && rhs);
+            case 'NAND': return !(lhs && rhs);
+            case 'NOR': return !(lhs && rhs);
+            case 'WHERE': return rhs;
+            default: throw new Error(`Invalid Filter. Bad logic value: ${logic}`);
+        }
+    }
+    static execCondition(record, condition) {
+        const data = record[condition.key];
+        if (condition.type === 'Number') {
+            if (typeof condition.constant !== 'number' || typeof data !== 'number')
+                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
+            const n = data;
+            const constant = condition.constant;
+            switch (condition.operation) {
+                case 'eq': return n === constant;
+                case '!eq': return n !== constant;
+                case 'gt': return n > constant;
+                case 'gte': return n >= constant;
+                case 'lt': return n < constant;
+                case 'lte': return n <= constant;
+                default: throw new Error('Invalid Filter. Operation does not match type');
+            }
+        }
+        if (condition.type === 'String') {
+            if (typeof condition.constant !== 'string' || typeof data !== 'string')
+                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
+            const str = data;
+            const constant = condition.constant;
+            switch (condition.operation) {
+                case 'contains': return str.includes(constant);
+                case '!contains': return !str.includes(constant);
+                case 'is': return str === constant;
+                case '!is': return str !== constant;
+                case 'isEmpty': return str === '';
+                case '!isEmpty': return str !== '';
+                default: throw new Error('Invalid Filter. Operation does not match type');
+            }
+        }
+        if (condition.type === 'Address') {
+            if (typeof condition.constant !== 'string' || typeof data !== 'string')
+                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
+            const str = data;
+            const constant = condition.constant;
+            switch (condition.operation) {
+                case 'contains': return str.toLowerCase().includes(constant.toLowerCase());
+                case '!contains': return !str.toLowerCase().includes(constant.toLowerCase());
+                case 'is': return str.toLowerCase() === constant.toLowerCase();
+                case '!is': return str.toLowerCase() !== constant.toLowerCase();
+                case 'isEmpty': return str === '';
+                case '!isEmpty': return str !== '';
+                default: throw new Error('Invalid Filter. Operation does not match type');
+            }
+        }
+        throw new Error('Invalid Filter. Unknown Type');
+    }
+}
+class FilterBuilder {
+    groups = [];
+    constructor() {
+        this.newGroup('WHERE');
+    }
+    static version() {
+        return Filter.version();
+    }
+    static new() {
+        return new FilterBuilder();
+    }
+    newGroup(logic) {
+        if (this.groups.length !== 0 && logic === 'WHERE')
+            throw new Error('Only the first groups can start with "WHERE"');
+        this.groups.push({ logic: 'WHERE', conditions: [] });
+        return this;
+    }
+    addCondition(logic, key, type, operation, constant) {
+        const group = this.groups[this.groups.length - 1];
+        if (group.conditions.length === 0 && logic !== 'WHERE')
+            throw new Error('Logic for the first condition of a group must be "WHERE"');
+        if (group.conditions.length > 0 && logic === 'WHERE')
+            throw new Error('Only the first condition of a group can be "WHERE"');
+        group.conditions.push({
+            logic,
+            key,
+            type,
+            operation,
+            constant
+        });
+        return this;
+    }
+    finalise() {
+        for (const group of this.groups) {
+            if (group.conditions.length === 0)
+                throw new Error('Bad Filter. All Groups must have atleast one condition');
+        }
+        return this.groups;
+    }
+    static schema() {
+        const logic = yup__namespace.string().oneOf(['AND', 'OR', 'XOR', 'NAND', 'NOR', 'WHERE']).required();
+        const condition = yup__namespace.object({
+            logic,
+            key: yup__namespace.string().required(),
+            type: yup__namespace.string().oneOf(['String', 'Address', 'Number']).required(),
+            operation: yup__namespace.string().when('type', ([type], schema) => {
+                switch (type) {
+                    case 'String': return schema.oneOf(['contains', '!contains', 'is', '!is', 'isEmpty', '!isEmpty']);
+                    case 'Address': return schema.oneOf(['is', '!is', 'isEmpty', '!isEmpty']);
+                    case 'Number': return schema.oneOf(['String', 'Address', 'Number']);
+                    default: throw new Error('Invalid Filter Data Type');
+                }
+            }),
+            constant: yup__namespace.mixed().when('type', ([type]) => {
+                switch (type) {
+                    case 'String': return yup__namespace.string();
+                    case 'Address': return yup__namespace.string();
+                    case 'Number': return yup__namespace.number();
+                    default: throw new Error('Invalid Filter Data Type');
+                }
+            }),
+        });
+        return yup__namespace.array().of(yup__namespace.object({
+            logic,
+            conditions: yup__namespace.array().of(condition)
+        }));
+    }
 }
 
 const HANDLER_FUNCTION_CALL_V2_RAW_ID = 'handler_function_call_v2';
@@ -4122,6 +4378,32 @@ class HandlerFunctionCallV2 {
             handler: config
         };
     }
+    static validateCreate(options) {
+        const timePeriodRegex = /^(\d+)([SMHD])$/i;
+        const onchainEventSchema = yup__namespace.object({
+            timeBase: yup__namespace.string().oneOf(['blocks', 'time']).required(),
+            // Blocks config
+            nBlocks: yup__namespace.number()
+                .min(10)
+                .when('timeBase', ([timeBase], schema) => timeBase === 'blocks' ? schema.required() : schema),
+            // Or Time config
+            timePeriod: yup__namespace.string()
+                .matches(timePeriodRegex, 'timePeriod must be of the format n[s|m|h|d], eg 10s for 10 seconds')
+                .when('timeBase', ([timeBase], schema) => timeBase === 'time' ? schema.required() : schema),
+            startTime: yup__namespace.number().default(0),
+            // Debouncing. Default is 0
+            debounceCount: yup__namespace.number(),
+            // Functions
+            functions: FunctionBuilder.schema(),
+            // Trigger
+            triggerOn: yup__namespace.string().oneOf(['always', 'filter']).default('always'),
+            latch: yup__namespace.boolean().default(false),
+            // Filter
+            filterVersion: yup__namespace.string().when('triggerOn', ([triggerOn], schema) => triggerOn === 'filter' ? schema.required() : schema),
+            filter: FilterBuilder.schema().when('triggerOn', ([triggerOn], schema) => triggerOn === 'filter' ? schema.required() : schema),
+        });
+        return onchainEventSchema.validate(options);
+    }
 }
 
 class Trigger {
@@ -4129,7 +4411,7 @@ class Trigger {
         switch (id) {
             case 'PollFunctionV2': return HandlerFunctionCallV2.SimpleToRaw(name, network, config);
             case 'PollFunctionV1': return HandlerFunctionCall.SimpleToRaw(name, network, config);
-            case 'OnchainEventV2': return HandlerOnchainEvent.SimpleToRaw(name, network, config);
+            case 'OnchainEventV1': return HandlerOnchainEvent.SimpleToRaw(name, network, config);
             default:
                 throw new Error('Invalid Trigger ID');
         }
@@ -4265,6 +4547,13 @@ class AlertBuilder {
         this.network = network;
         return this;
     }
+    /**
+     * Call withTrigger with one of the TriggerConfig types:
+     * PollFunctionV2 | PollFunctionV1 | OnchainEventV1
+     * @param id Simple ID
+     * @param options Desired trigger configuration
+     * @returns self for piping
+     */
     withTrigger(id, options) {
         this.triggerId = id;
         this.trigger = options;
@@ -4275,13 +4564,25 @@ class AlertBuilder {
         this.notification = options;
         return this;
     }
-    config() {
+    async validate() {
+        // Validate trigger
+        switch (this.triggerId) {
+            case 'OnchainEventV1': return HandlerOnchainEvent.validateCreate(this.trigger);
+            case 'PollFunctionV1': return HandlerFunctionCall.validateCreate(this.trigger);
+            case 'PollFunctionV2': return HandlerFunctionCallV2.validateCreate(this.trigger);
+        }
+        switch (this.notificationId) {
+            case 'Discord': return NotifyDiscordWebhook.validateCreate(this.notification);
+        }
+    }
+    async config() {
         if (this.trigger === undefined || this.triggerId === undefined)
             throw new Error('Trigger not configured');
         if (this.notification === undefined || this.notificationId === undefined)
             throw new Error('Notification not configured');
         if (this.network === undefined)
             throw new Error('Network not configured');
+        await this.validate();
         return {
             name: this.name,
             network: this.network,
@@ -4293,168 +4594,6 @@ class AlertBuilder {
     }
 }
 
-class FunctionBuilder {
-    api;
-    data = [];
-    constructor(api) {
-        this.api = api;
-    }
-    static create(api) {
-        return new FunctionBuilder(api);
-    }
-    getAbiHash(abi) {
-        if (this.api === undefined)
-            throw new Error('FunctionBuilder must be initialised with api');
-        return this.api.getAbiHash(abi);
-    }
-    async addFunction(address, func, args, abi) {
-        const contract = new ethers.ethers.Contract(address, abi);
-        contract.interface.encodeFunctionData(func, args);
-        this.data.push({
-            address,
-            bytecode: contract.interface.encodeFunctionData(func, args),
-            abiHash: await this.getAbiHash(abi),
-            function: func,
-        });
-        return this;
-    }
-    get() {
-        return this.data;
-    }
-}
-
-class Filter {
-    static version() {
-        return 'v1';
-    }
-    static execute(record, groupsIn, version = 'v1') {
-        // Deep copy to so we can edit the object during recursion
-        const groups = JSON.parse(JSON.stringify(groupsIn));
-        let lhs = true;
-        for (const group of groups) {
-            const rhs = Filter.process(record, group.conditions);
-            lhs = Filter.execLogic(lhs, group.logic, rhs);
-        }
-        return lhs;
-    }
-    static process(record, conditions, lhs) {
-        const condition = conditions.shift();
-        if (!condition) {
-            if (lhs === undefined)
-                return true;
-            return lhs;
-        }
-        // lhs <logic> rhs
-        const rhs = Filter.execCondition(record, condition);
-        if (lhs === undefined || condition.logic === 'WHERE')
-            return Filter.process(record, conditions, rhs);
-        if (condition.logic === undefined)
-            throw new Error('Invalid filter. Condition must have logic value');
-        const next = Filter.execLogic(lhs, condition.logic, rhs);
-        return Filter.process(record, conditions, next);
-    }
-    static execLogic(lhs, logic, rhs) {
-        switch (logic) {
-            case 'AND': return lhs && rhs;
-            case 'OR': return lhs || rhs;
-            case 'XOR': return (lhs || rhs) && !(lhs && rhs);
-            case 'NAND': return !(lhs && rhs);
-            case 'NOR': return !(lhs && rhs);
-            case 'WHERE': return rhs;
-            default: throw new Error(`Invalid Filter. Bad logic value: ${logic}`);
-        }
-    }
-    static execCondition(record, condition) {
-        const data = record[condition.key];
-        if (condition.type === 'Number') {
-            if (typeof condition.constant !== 'number' || typeof data !== 'number')
-                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
-            const n = data;
-            const constant = condition.constant;
-            switch (condition.operation) {
-                case 'eq': return n === constant;
-                case '!eq': return n !== constant;
-                case 'gt': return n > constant;
-                case 'gte': return n >= constant;
-                case 'lt': return n < constant;
-                case 'lte': return n <= constant;
-                default: throw new Error('Invalid Filter. Operation does not match type');
-            }
-        }
-        if (condition.type === 'String') {
-            if (typeof condition.constant !== 'string' || typeof data !== 'string')
-                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
-            const str = data;
-            const constant = condition.constant;
-            switch (condition.operation) {
-                case 'contains': return str.includes(constant);
-                case '!contains': return !str.includes(constant);
-                case 'is': return str === constant;
-                case '!is': return str !== constant;
-                case 'isEmpty': return str === '';
-                case '!isEmpty': return str !== '';
-                default: throw new Error('Invalid Filter. Operation does not match type');
-            }
-        }
-        if (condition.type === 'Address') {
-            if (typeof condition.constant !== 'string' || typeof data !== 'string')
-                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
-            const str = data;
-            const constant = condition.constant;
-            switch (condition.operation) {
-                case 'contains': return str.toLowerCase().includes(constant.toLowerCase());
-                case '!contains': return !str.toLowerCase().includes(constant.toLowerCase());
-                case 'is': return str.toLowerCase() === constant.toLowerCase();
-                case '!is': return str.toLowerCase() !== constant.toLowerCase();
-                case 'isEmpty': return str === '';
-                case '!isEmpty': return str !== '';
-                default: throw new Error('Invalid Filter. Operation does not match type');
-            }
-        }
-        throw new Error('Invalid Filter. Unknown Type');
-    }
-}
-class FilterBuilder {
-    groups = [];
-    constructor() {
-        this.newGroup('WHERE');
-    }
-    static version() {
-        return Filter.version();
-    }
-    static new() {
-        return new FilterBuilder();
-    }
-    newGroup(logic) {
-        if (this.groups.length !== 0 && logic === 'WHERE')
-            throw new Error('Only the first groups can start with "WHERE"');
-        this.groups.push({ logic: 'WHERE', conditions: [] });
-        return this;
-    }
-    addCondition(logic, key, type, operation, constant) {
-        const group = this.groups[this.groups.length - 1];
-        if (group.conditions.length === 0 && logic !== 'WHERE')
-            throw new Error('Logic for the first condition of a group must be "WHERE"');
-        if (group.conditions.length > 0 && logic === 'WHERE')
-            throw new Error('Only the first condition of a group can be "WHERE"');
-        group.conditions.push({
-            logic,
-            key,
-            type,
-            operation,
-            constant
-        });
-        return this;
-    }
-    finalise() {
-        for (const group of this.groups) {
-            if (group.conditions.length === 0)
-                throw new Error('Bad Filter. All Groups must have atleast one condition');
-        }
-        return this.groups;
-    }
-}
-
 var index$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Trigger: Trigger,