denotify-client 1.0.0

package/dist/notifications/notification.js

@@ -0,0 +1,8 @@
+import { NotifyDiscordWebhook } from "./notify_discord_webhook.js";
+export class Notification {
+    static SimpleToRaw(id, config) {
+        switch (id) {
+            case 'Discord': return NotifyDiscordWebhook.SimpleToRaw(config);
+        }
+    }
+}

package/dist/notifications/notify_discord_webhook.js

@@ -0,0 +1,10 @@
+export const NOTIFY_DISCORD_WEBHOOK_RAW_ID = 'notify_discord_webhook';
+export class NotifyDiscordWebhook {
+    static SimpleToRaw(config) {
+        return {
+            name: '',
+            notify_type: NOTIFY_DISCORD_WEBHOOK_RAW_ID,
+            notify: config
+        };
+    }
+}

package/dist/triggers/handler_function_call.js

@@ -0,0 +1 @@
+export {};

package/dist/triggers/handler_function_call_v2.js

@@ -0,0 +1,12 @@
+const HANDLER_FUNCTION_CALL_V2_RAW_ID = 'handler_function_call_v2';
+export class HandlerFunctionCallV2 {
+    static SimpleToRaw(name, network, config) {
+        return {
+            alertType: 'event',
+            network,
+            nickname: name,
+            type: HANDLER_FUNCTION_CALL_V2_RAW_ID,
+            handler: config
+        };
+    }
+}

package/dist/triggers/handler_onchain_event.js

@@ -0,0 +1 @@
+export {};

package/dist/triggers/trigger.js

@@ -0,0 +1,10 @@
+import { HandlerFunctionCallV2 } from "./handler_function_call_v2.js";
+export class Trigger {
+    static SimpleToRaw(name, id, network, config) {
+        switch (id) {
+            case 'PollFunctionV2': return HandlerFunctionCallV2.SimpleToRaw(name, network, config);
+            default:
+                throw new Error('Invalid Trigger ID');
+        }
+    }
+}

package/dist/types/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util/filter.js

@@ -0,0 +1,131 @@
+export 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');
+    }
+}
+export 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;
+    }
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) ROBO LABS <info@robolabs.biz> (https://robolabs.biz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,64 @@
+{
+	"version": "1.0.0",
+	"name": "denotify-client",
+	"umd:name": "denotify-client",
+	"repository": "robo-labs/denotify-client",
+	"description": "Client module for the Robo Labs DeNotify Crypto Alerts API",
+	"unpkg": "dist/index.min.js",
+	"module": "dist/index.mjs",
+	"main": "dist/index.js",
+	"types": "types/index.d.ts",
+	"license": "MIT",
+	"type": "module",
+	"author": {
+		"name": "Robo Labs",
+		"email": "info@robolabs.biz",
+		"url": "https://robolabs.biz"
+	},
+	"files": [
+		"dist",
+		"types"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/index.mjs",
+			"require": "./dist/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"engines": {
+		"node": ">=12"
+	},
+	"scripts": {
+		"build": "rollup -c",
+		"prepublishOnly": "npm run build",
+		"types": "tsc --noEmit",
+		"test": "uvu -r tsm test"
+	},
+	"keywords": [
+		"crypto",
+		"web3",
+		"alerts",
+		"ethereum",
+		"module",
+		"keywords"
+	],
+	"devDependencies": {
+		"@rollup/plugin-node-resolve": "13.1.3",
+		"@supabase/supabase-js": "^2.10.0",
+		"axois": "^0.0.1-security",
+		"ethers": "^6.0.8",
+		"rollup": "2.66.1",
+		"rollup-plugin-terser": "7.0.2",
+		"rollup-plugin-typescript2": "0.27.1",
+		"tsm": "2.2.1",
+		"typescript": "4.5.5",
+		"uvu": "0.5.3"
+	},
+	"dependencies": {
+		"@supabase/supabase-js": "^2.10.0",
+		"@types/axios": "^0.14.0",
+		"axois": "^0.0.1-security",
+		"ethers": "^6.0.8"
+	}
+}

package/types/alertbuilder.d.ts

@@ -0,0 +1,17 @@
+import { NotificationConfig, NotificationTypeId } from "./notifications/notification.js";
+import { Network, TriggerConfig, TriggerTypeId } from "./triggers/trigger.js";
+import { AlertConfig } from "./types/types.js";
+export declare class AlertBuilder {
+    private name;
+    private network?;
+    private triggerId?;
+    private trigger?;
+    private notificationId?;
+    private notification?;
+    private constructor();
+    static create(name: string): AlertBuilder;
+    onNetwork(network: Network): AlertBuilder;
+    withTrigger<T = TriggerConfig>(id: TriggerTypeId, options: T): AlertBuilder;
+    withNotification<T = NotificationConfig>(id: NotificationTypeId, options: T): AlertBuilder;
+    config(): AlertConfig;
+}

package/types/client.d.ts

@@ -0,0 +1,14 @@
+import { DeNotifyOptions } from "./types/types";
+export declare class DeNotifyClient {
+    private url;
+    private token;
+    private headers;
+    private constructor();
+    static create(options: DeNotifyOptions): Promise<DeNotifyClient>;
+    getAlert(id: number): Promise<any>;
+    getAlerts(): Promise<any>;
+    createAlert(): Promise<void>;
+    deleteAlert(id: number): Promise<any>;
+    private request;
+    getAbiHash(abi: any): Promise<any>;
+}

package/types/denotifyclient.d.ts

@@ -0,0 +1,27 @@
+import { AlertConfig, DeNotifyOptions } from "./types/types.js";
+import { TriggerUpdate } from "./triggers/trigger.js";
+export declare class DeNotifyClient {
+    private url;
+    private token;
+    private headers;
+    private constructor();
+    static create(options: DeNotifyOptions): Promise<DeNotifyClient>;
+    alertHistory(id: number | null, pagination?: {
+        page?: number;
+        size?: number;
+    }): Promise<any>;
+    getAlert(id: number): Promise<any>;
+    getAlerts(): Promise<any>;
+    createAlert(config: AlertConfig): Promise<any>;
+    deleteAlert(id: number): Promise<any>;
+    private request;
+    getAbi(network: string, address: string): Promise<{
+        abi: any[];
+        proxy?: string;
+    }>;
+    getAbiHash(abi: any): Promise<any>;
+    setAlertName(triggerId: number, name: string): Promise<void>;
+    enableAlert(triggerId: number): Promise<void>;
+    disableAlert(triggerId: number): Promise<void>;
+    updateTrigger(triggerId: number, update: TriggerUpdate): Promise<any>;
+}

package/types/examples/aave-healthcheck.d.ts

@@ -0,0 +1 @@
+export {};

package/types/examples/delete-alert.d.ts

@@ -0,0 +1 @@
+export {};

package/types/functionbuilder.d.ts

@@ -0,0 +1,16 @@
+import { DeNotifyClient } from "./denotifyclient.js";
+export declare type FunctionCallerConfig = {
+    address: string;
+    bytecode: string;
+    abiHash: string;
+    function: string;
+}[];
+export declare class FunctionBuilder {
+    private api?;
+    private data;
+    private constructor();
+    static create(api?: DeNotifyClient): FunctionBuilder;
+    getAbiHash(abi: any): Promise<string>;
+    addFunction<T = any>(address: string, func: string, args: T[], abi: any): Promise<this>;
+    get(): FunctionCallerConfig;
+}

package/types/index.d.ts

@@ -0,0 +1,2 @@
+import { DeNotifyClient } from "./denotifyclient.js";
+export { DeNotifyClient };

package/types/notifications/notification.d.ts

@@ -0,0 +1,15 @@
+import { DiscordWebhook, NotifyDiscordWebhookRawConfig, NotifyDiscordWebhookRawId, NotifyDiscordWebhookRawResponse, NotifyDiscordWebhookRawUpdate } from "./notify_discord_webhook.js";
+export declare type NotificationTypeId = 'Discord';
+export declare type NotificationConfig = DiscordWebhook;
+export declare type NotifyRawId = NotifyDiscordWebhookRawId;
+export declare type NotifyRawConfig = NotifyDiscordWebhookRawConfig;
+export declare type NotifyRawResponse = NotifyDiscordWebhookRawResponse;
+export declare type NotifyRawUpdate = NotifyDiscordWebhookRawUpdate;
+export declare type NotificationRawConfig = {
+    name: string;
+    notify_type: NotifyRawId;
+    notify: NotifyRawConfig;
+};
+export declare class Notification {
+    static SimpleToRaw(id: NotificationTypeId, config: NotificationConfig): NotificationRawConfig;
+}

package/types/notifications/notify_discord_webhook.d.ts

@@ -0,0 +1,32 @@
+import { NotificationRawConfig } from "./notification.js";
+export declare type DiscordWebhook = {
+    url: string;
+    username?: string;
+    avatar_url?: string;
+    message: string;
+};
+export declare type NotifyDiscordWebhookRawId = 'notify_discord_webhook';
+export declare const NOTIFY_DISCORD_WEBHOOK_RAW_ID = "notify_discord_webhook";
+export declare type NotifyDiscordWebhookRawConfig = {
+    url: string;
+    username?: string;
+    avatar_url?: string;
+    message: string;
+};
+export declare type NotifyDiscordWebhookRawResponse = {
+    id: number;
+    created_at: string;
+    url: string;
+    username: string;
+    avatar_url: string;
+    message: string;
+};
+export declare type NotifyDiscordWebhookRawUpdate = {
+    url?: string;
+    username?: string;
+    avatar_url?: string;
+    message?: string;
+};
+export declare class NotifyDiscordWebhook {
+    static SimpleToRaw(config: DiscordWebhook): NotificationRawConfig;
+}

package/types/temp.d.ts

@@ -0,0 +1 @@
+export {};

package/types/triggers/handler_function_call.d.ts

@@ -0,0 +1,39 @@
+import { Condition } from "../types/types.js";
+export declare type PollFunctionV1 = {};
+export declare type HandlerFunctionCallRawConfig = {
+    nBlocks: number;
+    address: string;
+    abi: any;
+    fixedArgs?: (string | number)[];
+    function: string;
+    condition: Condition;
+    responseArgIndex?: number;
+    responseArgDecimals?: number;
+    constant?: number;
+};
+export declare type HandlerFunctionCallUpdate = Partial<HandlerFunctionCallRawConfig>;
+export declare type HandlerFunctionCallRawResponse = {
+    id: number;
+    created_at: string;
+    nBlocks: number;
+    address: string;
+    fixedArgs: string[];
+    responseArgIndex: number;
+    responseArgDecimals: number;
+    function: string;
+    condition: Condition;
+    constant: number;
+    abi: string[];
+    version: number;
+};
+export declare type HandlerFunctionCallRawUpdate = {
+    address?: string;
+    function?: string;
+    abi?: any;
+    constant?: number;
+    nBlocks?: number;
+    confition?: Condition;
+    fixedArgs?: (string | number)[];
+    responseArgIndex?: number;
+    responseArgDecimals?: number;
+};

package/types/triggers/handler_function_call_v2.d.ts

@@ -0,0 +1,65 @@
+import { FunctionCallerConfig } from "../functionbuilder.js";
+import { Condition } from "../types/types.js";
+import { FilterConfig } from "../util/filter.js";
+import { Network, TriggerRawConfig } from "./trigger.js";
+declare type TimeBase = 'blocks' | 'time';
+/**
+ * @typedef PollFunction
+ * @param {TimeBase} timeBase - Supports two poll period types. 'block' will test the trigger ever nBlocks blocks, 'time' will test the trigger as specified by timePeriod
+ * @param {number} nBlocks -
+ *
+ */
+export declare type PollFunctionV2 = {
+    timeBase: TimeBase;
+    nBlocks?: number;
+    timePeriod?: string | null;
+    startTime?: number;
+    debounceCount?: number;
+    functions: FunctionCallerConfig;
+    triggerOn: 'always' | 'filter';
+    latch?: boolean;
+    filterVersion?: string;
+    filter?: FilterConfig;
+};
+export declare type HandlerFunctionCallV2RawConfig = {
+    timeBase: TimeBase;
+    nBlocks?: number;
+    timePeriod?: string | null;
+    startTime?: number;
+    debounceCount?: number;
+    functions: FunctionCallerConfig;
+    triggerOn: 'always' | 'filter';
+    latch?: boolean;
+    filterVersion?: string;
+    filter?: FilterConfig;
+};
+export declare type HandlerFunctionCallV2Update = Partial<HandlerFunctionCallV2RawConfig>;
+export declare type HandlerFunctionCallV2RawResponse = {
+    id: number;
+    created_at: string;
+    nBlocks: number;
+    address: string;
+    fixedArgs: string[];
+    responseArgIndex: number;
+    responseArgDecimals: number;
+    function: string;
+    condition: Condition;
+    constant: number;
+    abi: string[];
+    version: number;
+};
+export declare type HandlerFunctionCallV2RawUpdate = {
+    address?: string;
+    function?: string;
+    abi?: any;
+    constant?: number;
+    nBlocks?: number;
+    confition?: Condition;
+    fixedArgs?: (string | number)[];
+    responseArgIndex?: number;
+    responseArgDecimals?: number;
+};
+export declare class HandlerFunctionCallV2 {
+    static SimpleToRaw(name: string, network: Network, config: PollFunctionV2): TriggerRawConfig;
+}
+export {};

package/types/triggers/handler_onchain_event.d.ts

@@ -0,0 +1,31 @@
+import { Condition } from "../util/filter.js";
+export declare type OnchainEventV1 = {};
+export declare type HandlerOnchainEventRawConfig = {
+    address: string;
+    event: string;
+    abi: any;
+    condition: Condition;
+    paramsIndex?: number;
+    paramsDecimals?: number;
+    constant?: number;
+};
+export declare type HandlerOnchainEventUpdate = Partial<HandlerOnchainEventRawConfig>;
+export declare type HandlerOnchainEventRawResponse = {
+    id: number;
+    created_at: string;
+    address: string;
+    event: string;
+    abi: any;
+    paramsIndex: number;
+    paramsDecimals: number;
+    condition: Condition;
+    constant: number;
+};
+export declare type HandlerOnchainEventRawUpdate = {
+    address?: string;
+    event?: string;
+    abi?: any;
+    paramsIndex?: number;
+    paramsDecimals?: number;
+    constant?: number;
+};

package/types/triggers/trigger.d.ts

@@ -0,0 +1,20 @@
+import { HandlerFunctionCallRawConfig, HandlerFunctionCallUpdate, PollFunctionV1 } from "./handler_function_call.js";
+import { HandlerOnchainEventRawConfig, HandlerOnchainEventUpdate, OnchainEventV1 } from "./handler_onchain_event.js";
+import { HandlerFunctionCallV2RawConfig, HandlerFunctionCallV2Update, PollFunctionV2 } from "./handler_function_call_v2.js";
+export declare type Network = 'avalanche' | 'ethereum';
+export declare type TriggerConfig = PollFunctionV2 | PollFunctionV1 | OnchainEventV1;
+export declare type TriggerTypeId = 'PollFunctionV2' | 'OnchainEventV2' | 'FunctionEventV2';
+export declare type TriggerUpdate = HandlerFunctionCallV2Update | HandlerFunctionCallUpdate | HandlerOnchainEventUpdate;
+export declare type TriggerTypeRawId = 'handler_function_call' | 'onchain_event_call_v2' | 'handler_function_call_v2';
+export declare type TriggerOn = 'event' | 'latch';
+export declare type HandlerRawConfig = HandlerFunctionCallRawConfig | HandlerOnchainEventRawConfig | HandlerFunctionCallV2RawConfig;
+export declare type TriggerRawConfig = {
+    nickname: string;
+    type: TriggerTypeRawId;
+    alertType: TriggerOn;
+    network: Network;
+    handler: HandlerRawConfig;
+};
+export declare class Trigger {
+    static SimpleToRaw(name: string, id: TriggerTypeId, network: Network, config: TriggerConfig): TriggerRawConfig;
+}

package/types/types/notification.d.ts

@@ -0,0 +1,7 @@
+declare type DiscordWebhook = {
+    url: string;
+    message: string;
+    username?: string;
+    avatar_url?: string;
+};
+declare type NotificationType = DiscordWebhook;

package/types/types/trigger.d.ts

@@ -0,0 +1,29 @@
+import { FilterConfig } from "../util/filter";
+export declare type FunctionCallerConfig = {
+    address: string;
+    bytecode: string;
+    abiHash: string;
+    function: string;
+}[];
+export declare type TriggerTypeId = 'PollFunctionV2' | 'OnchainEventV2' | 'FunctionEventV2';
+declare type TimeBase = 'blocks' | 'time';
+/**
+ * @typedef PollFunction
+ * @param {TimeBase} timeBase - Supports two poll period types. 'block' will test the trigger ever nBlocks blocks, 'time' will test the trigger as specified by timePeriod
+ * @param {number} nBlocks -
+ *
+ */
+export declare type PollFunction = {
+    timeBase: TimeBase;
+    nBlocks?: number;
+    timePeriod?: string | null;
+    startTime?: number;
+    debounceCount?: number;
+    functions: FunctionCallerConfig;
+    triggerOn: 'always' | 'filter';
+    latch?: boolean;
+    filterVersion?: string;
+    filter?: FilterConfig;
+};
+export declare type TriggerType = PollFunction;
+export {};

package/types/types/types.d.ts

@@ -0,0 +1,20 @@
+import { NotificationConfig, NotificationTypeId } from "../notifications/notification.js";
+import { Network, TriggerConfig, TriggerTypeId } from "../triggers/trigger.js";
+export declare type Condition = '>' | '>=' | '<' | '<=' | '=' | 'true';
+export declare type TriggerOn = 'event' | 'latch';
+export declare type DeNotifyOptions = {
+    email?: string;
+    password?: string;
+    projectId?: string;
+    key?: string;
+    url?: string;
+    anonKey?: string;
+};
+export declare type AlertConfig = {
+    name: string;
+    network: Network;
+    triggerId: TriggerTypeId;
+    trigger: TriggerConfig;
+    notificationId: NotificationTypeId;
+    notification: NotificationConfig;
+};

package/types/util/filter.d.ts

@@ -0,0 +1,35 @@
+declare type Logic = 'AND' | 'OR' | 'XOR' | 'NAND' | 'NOR' | 'WHERE';
+declare type NumericOperation = 'eq' | '!eq' | 'gt' | 'gte' | 'lt' | 'lte';
+declare type StringOperation = 'contains' | '!contains' | 'is' | '!is' | 'isEmpty' | '!isEmpty';
+declare type AddressOperation = 'is' | '!is' | 'isEmpty' | '!isEmpty';
+declare type FilterDataTypes = 'String' | 'Address' | 'Number';
+declare type FilterOpertationType = NumericOperation | StringOperation | AddressOperation;
+export declare type Condition = {
+    logic?: Logic;
+    key: string;
+    type: FilterDataTypes;
+    operation: FilterOpertationType;
+    constant: string | number;
+};
+export declare type ConditionGroup = {
+    logic: Logic;
+    conditions: Condition[];
+};
+export declare type FilterConfig = ConditionGroup[];
+export declare class Filter {
+    static version(): string;
+    static execute(record: any, groupsIn: FilterConfig, version?: string): boolean;
+    private static process;
+    private static execLogic;
+    private static execCondition;
+}
+export declare class FilterBuilder {
+    private groups;
+    constructor();
+    static version(): string;
+    static new(): FilterBuilder;
+    newGroup(logic: Logic): FilterBuilder;
+    addCondition(logic: Logic, key: string, type: FilterDataTypes, operation: FilterOpertationType, constant: string | number): FilterBuilder;
+    finalise(): ConditionGroup[];
+}
+export {};