@limetech/lime-crm-building-blocks 1.99.0 → 1.100.0

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-builder.js

@@ -0,0 +1,225 @@
+import { h } from "@stencil/core";
+import { Operator, } from "@limetech/lime-web-components";
+/**
+ * Lime Query Filter Builder
+ *
+ * Entry component for building Lime Query filter expressions.
+ * This component wraps the expression router and adds promotion logic
+ * for handling Add buttons and expression structure.
+ *
+ * Unlike the expression router (which is pure routing), this component
+ * contains business logic for promoting expressions and managing the
+ * filter structure.
+ *
+ * @private
+ */
+export class LimeQueryFilterBuilderComponent {
+    constructor() {
+        this.handleAddFirstCondition = () => {
+            const newExpression = {
+                key: '',
+                op: Operator.EQUALS,
+                exp: '',
+            };
+            this.expressionChange.emit(newExpression);
+        };
+        this.handlePromoteAndAdd = () => {
+            if (!this.expression) {
+                return;
+            }
+            // Wrap current expression in AND and add a new comparison
+            const newExpression = {
+                op: Operator.AND,
+                exp: [
+                    this.expression,
+                    {
+                        key: '',
+                        op: Operator.EQUALS,
+                        exp: '',
+                    },
+                ],
+            };
+            this.expressionChange.emit(newExpression);
+        };
+        this.handleExpressionChange = (event) => {
+            var _a;
+            event.stopPropagation();
+            this.expressionChange.emit((_a = event.detail) !== null && _a !== void 0 ? _a : undefined);
+        };
+    }
+    render() {
+        if (!this.expression) {
+            return this.renderEmptyState();
+        }
+        // Check if we need to show promotion UI (comparison or NOT)
+        if (this.needsPromotion()) {
+            return this.renderWithPromotionButton();
+        }
+        // AND/OR groups handle their own Add buttons
+        return (h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression, onExpressionChange: this.handleExpressionChange }));
+    }
+    needsPromotion() {
+        if (!this.expression) {
+            return false;
+        }
+        // Basic comparison needs promotion
+        if ('key' in this.expression) {
+            return true;
+        }
+        // NOT needs promotion
+        return this.expression.op === Operator.NOT;
+    }
+    renderEmptyState() {
+        return (h("limel-button", { label: "Add a condition", icon: "plus_math", onClick: this.handleAddFirstCondition }));
+    }
+    renderWithPromotionButton() {
+        return (h("div", { class: "expression-with-promotion" }, h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression, onExpressionChange: this.handleExpressionChange }), h("limel-button", { label: "Add another condition", icon: "plus_math", onClick: this.handlePromoteAndAdd })));
+    }
+    static get is() { return "limebb-lime-query-filter-builder"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["lime-query-filter-builder.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["lime-query-filter-builder.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "platform": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LimeWebComponentPlatform",
+                    "resolved": "LimeWebComponentPlatform",
+                    "references": {
+                        "LimeWebComponentPlatform": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::LimeWebComponentPlatform"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Platform service provider"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "context": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LimeWebComponentContext",
+                    "resolved": "LimeWebComponentContext",
+                    "references": {
+                        "LimeWebComponentContext": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::LimeWebComponentContext"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Component context"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "limetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The limetype being queried (e.g., \"deal\", \"company\")"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "limetype",
+                "reflect": false
+            },
+            "activeLimetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "The limetype of the active object (for %activeObject% placeholders)"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "active-limetype",
+                "reflect": false
+            },
+            "expression": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Expression | undefined",
+                    "resolved": "undefined | { key: string; op: BasicOperator; exp: ExpressionValue; } | { key: string; op: Operator.IN; exp: ExpressionValue[]; } | { op: Operator.AND | Operator.OR; exp: Expression[]; } | { op: Operator.NOT; exp: Expression; } | { type: \"filter\"; key: string; op: Operator.IN; exp: string; }",
+                    "references": {
+                        "Expression": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::Expression"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The filter expression to build"
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "expressionChange",
+                "name": "expressionChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted when the filter expression changes\nEmits undefined when expression should be removed"
+                },
+                "complexType": {
+                    "original": "Expression | undefined",
+                    "resolved": "undefined | { key: string; op: BasicOperator; exp: ExpressionValue; } | { key: string; op: Operator.IN; exp: ExpressionValue[]; } | { op: Operator.AND | Operator.OR; exp: Expression[]; } | { op: Operator.NOT; exp: Expression; } | { type: \"filter\"; key: string; op: Operator.IN; exp: string; }",
+                    "references": {
+                        "Expression": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::Expression"
+                        }
+                    }
+                }
+            }];
+    }
+}

package/dist/collection/components/lime-query-builder/lime-query-builder.js

@@ -9,7 +9,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { h } from "@stencil/core";
-import { Operator, SelectLimeTypes as Limetypes, } from "@limetech/lime-web-components";
+import { SelectLimeTypes as Limetypes, } from "@limetech/lime-web-components";
 import { isLimeQuerySupported, } from "./lime-query-validation";
 /**
  * Lime Query Builder Component
@@ -37,6 +37,7 @@ import { isLimeQuerySupported, } from "./lime-query-validation";
  * (e.g., `%activeObject%.company` references the company of the active object).
  *
  * @exampleComponent limebb-example-lime-query-builder-basic
+ * @exampleComponent limebb-example-lime-query-builder-with-active-limetype
  * @private
  */
 export class LimeQueryBuilder {
@@ -44,18 +45,11 @@ export class LimeQueryBuilder {
         this.mode = 'gui';
         this.codeValue = '';
         this.limetype = '';
-        this.filter = {
-            op: Operator.AND,
-            exp: [],
-        };
         this.handleLimetypeChange = (event) => {
             event.stopPropagation();
             this.limetype = event.detail;
             // Reset filter when limetype changes
-            this.filter = {
-                op: Operator.AND,
-                exp: [],
-            };
+            this.filter = undefined;
             // Reset response format when limetype changes
             this.internalResponseFormat = {
                 object: {
@@ -65,17 +59,9 @@ export class LimeQueryBuilder {
             this.emitChange();
         };
         this.handleFilterChange = (event) => {
+            var _a;
             event.stopPropagation();
-            const expression = event.detail;
-            if (expression === undefined) {
-                this.filter = {
-                    op: Operator.AND,
-                    exp: [],
-                };
-            }
-            else {
-                this.filter = expression;
-            }
+            this.filter = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
             this.emitChange();
         };
         this.handleResponseFormatChange = (event) => {
@@ -101,7 +87,7 @@ export class LimeQueryBuilder {
                 }
                 // Update internal state from parsed query
                 this.limetype = parsed.limetype || '';
-                this.filter = this.normalizeFilter(parsed.filter);
+                this.filter = parsed.filter;
                 this.internalResponseFormat = parsed.responseFormat;
                 this.limit = parsed.limit;
                 this.mode = 'gui';
@@ -142,7 +128,7 @@ export class LimeQueryBuilder {
         }
         if (this.value) {
             this.limetype = this.value.limetype || '';
-            this.filter = this.normalizeFilter(this.value.filter);
+            this.filter = this.value.filter;
             this.internalResponseFormat = this.value.responseFormat;
             this.limit = this.value.limit;
         }
@@ -157,26 +143,10 @@ export class LimeQueryBuilder {
     render() {
         const guiSupported = this.checkGuiSupport();
         const showCodeMode = !this.guiModeEnabled || this.mode === 'code';
-        return (h("div", { key: '5ff70a352e3e57ff4c51d44627bd4b5ed367fff4', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
+        return (h("div", { key: '0b4d2bb5b4d503a775d8d3215e1e4c74fdb1eceb', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
             ? this.renderCodeMode(guiSupported)
             : this.renderGuiMode()));
     }
-    /**
-     * Normalize filter to ensure top-level is an AND group.
-     * This ensures Add buttons are available in the UI.
-     * @param filter
-     */
-    normalizeFilter(filter) {
-        if (!filter) {
-            return { op: Operator.AND, exp: [] };
-        }
-        // If it's already an AND at the top level, keep it
-        if ('op' in filter && filter.op === Operator.AND) {
-            return filter;
-        }
-        // Otherwise wrap in AND
-        return { op: Operator.AND, exp: [filter] };
-    }
     emitChange() {
         // Only emit in GUI mode
         if (this.mode === 'code') {
@@ -298,7 +268,7 @@ export class LimeQueryBuilder {
         if (!this.limetype) {
             return;
         }
-        return (h("div", { class: "filter-section" }, h("h4", { class: "section-label" }, "Filter Conditions"), h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.filter, onExpressionChange: this.handleFilterChange })));
+        return (h("div", { class: "filter-section" }, h("h4", { class: "section-label" }, "Filter Conditions"), h("limebb-lime-query-filter-builder", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.filter, onExpressionChange: this.handleFilterChange })));
     }
     renderQueryOptionsSection() {
         var _a;

package/dist/components/lime-query-filter-builder.js

@@ -0,0 +1,129 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { Z as Zt } from './index.esm.js';
+import { d as defineCustomElement$6 } from './lime-query-filter-comparison.js';
+import { d as defineCustomElement$3, a as defineCustomElement$4, b as defineCustomElement$5 } from './lime-query-filter-expression.js';
+import { d as defineCustomElement$2 } from './lime-query-value-input.js';
+import { d as defineCustomElement$1 } from './property-selector.js';
+
+const limeQueryFilterBuilderCss = ".expression-with-promotion{display:flex;flex-direction:column;gap:1rem}";
+const LimebbLimeQueryFilterBuilderStyle0 = limeQueryFilterBuilderCss;
+
+const LimeQueryFilterBuilderComponent = /*@__PURE__*/ proxyCustomElement(class LimeQueryFilterBuilderComponent extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        this.expressionChange = createEvent(this, "expressionChange", 7);
+        this.handleAddFirstCondition = () => {
+            const newExpression = {
+                key: '',
+                op: Zt.EQUALS,
+                exp: '',
+            };
+            this.expressionChange.emit(newExpression);
+        };
+        this.handlePromoteAndAdd = () => {
+            if (!this.expression) {
+                return;
+            }
+            // Wrap current expression in AND and add a new comparison
+            const newExpression = {
+                op: Zt.AND,
+                exp: [
+                    this.expression,
+                    {
+                        key: '',
+                        op: Zt.EQUALS,
+                        exp: '',
+                    },
+                ],
+            };
+            this.expressionChange.emit(newExpression);
+        };
+        this.handleExpressionChange = (event) => {
+            var _a;
+            event.stopPropagation();
+            this.expressionChange.emit((_a = event.detail) !== null && _a !== void 0 ? _a : undefined);
+        };
+    }
+    render() {
+        if (!this.expression) {
+            return this.renderEmptyState();
+        }
+        // Check if we need to show promotion UI (comparison or NOT)
+        if (this.needsPromotion()) {
+            return this.renderWithPromotionButton();
+        }
+        // AND/OR groups handle their own Add buttons
+        return (h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression, onExpressionChange: this.handleExpressionChange }));
+    }
+    needsPromotion() {
+        if (!this.expression) {
+            return false;
+        }
+        // Basic comparison needs promotion
+        if ('key' in this.expression) {
+            return true;
+        }
+        // NOT needs promotion
+        return this.expression.op === Zt.NOT;
+    }
+    renderEmptyState() {
+        return (h("limel-button", { label: "Add a condition", icon: "plus_math", onClick: this.handleAddFirstCondition }));
+    }
+    renderWithPromotionButton() {
+        return (h("div", { class: "expression-with-promotion" }, h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression, onExpressionChange: this.handleExpressionChange }), h("limel-button", { label: "Add another condition", icon: "plus_math", onClick: this.handlePromoteAndAdd })));
+    }
+    static get style() { return LimebbLimeQueryFilterBuilderStyle0; }
+}, [1, "limebb-lime-query-filter-builder", {
+        "platform": [16],
+        "context": [16],
+        "limetype": [1],
+        "activeLimetype": [1, "active-limetype"],
+        "expression": [16]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["limebb-lime-query-filter-builder", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not", "limebb-lime-query-value-input", "limebb-property-selector"];
+    components.forEach(tagName => { switch (tagName) {
+        case "limebb-lime-query-filter-builder":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, LimeQueryFilterBuilderComponent);
+            }
+            break;
+        case "limebb-lime-query-filter-comparison":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$6();
+            }
+            break;
+        case "limebb-lime-query-filter-expression":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$5();
+            }
+            break;
+        case "limebb-lime-query-filter-group":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$4();
+            }
+            break;
+        case "limebb-lime-query-filter-not":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$3();
+            }
+            break;
+        case "limebb-lime-query-value-input":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$2();
+            }
+            break;
+        case "limebb-property-selector":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+
+export { LimeQueryFilterBuilderComponent as L, defineCustomElement as d };

package/dist/components/limebb-lime-query-builder.js

@@ -1,6 +1,7 @@
 import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
-import { T as Te, Z as Zt } from './index.esm.js';
+import { T as Te } from './index.esm.js';
 import { g as getNormalizedProperties, a as getPropertyFromPath, d as defineCustomElement$4 } from './property-selector.js';
+import { d as defineCustomElement$b } from './lime-query-filter-builder.js';
 import { d as defineCustomElement$a } from './lime-query-filter-comparison.js';
 import { d as defineCustomElement$7, a as defineCustomElement$8, b as defineCustomElement$9 } from './lime-query-filter-expression.js';
 import { d as defineCustomElement$6 } from './lime-query-value-input.js';
@@ -567,18 +568,11 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
         this.mode = 'gui';
         this.codeValue = '';
         this.limetype = '';
-        this.filter = {
-            op: Zt.AND,
-            exp: [],
-        };
         this.handleLimetypeChange = (event) => {
             event.stopPropagation();
             this.limetype = event.detail;
             // Reset filter when limetype changes
-            this.filter = {
-                op: Zt.AND,
-                exp: [],
-            };
+            this.filter = undefined;
             // Reset response format when limetype changes
             this.internalResponseFormat = {
                 object: {
@@ -588,17 +582,9 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
             this.emitChange();
         };
         this.handleFilterChange = (event) => {
+            var _a;
             event.stopPropagation();
-            const expression = event.detail;
-            if (expression === undefined) {
-                this.filter = {
-                    op: Zt.AND,
-                    exp: [],
-                };
-            }
-            else {
-                this.filter = expression;
-            }
+            this.filter = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
             this.emitChange();
         };
         this.handleResponseFormatChange = (event) => {
@@ -624,7 +610,7 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
                 }
                 // Update internal state from parsed query
                 this.limetype = parsed.limetype || '';
-                this.filter = this.normalizeFilter(parsed.filter);
+                this.filter = parsed.filter;
                 this.internalResponseFormat = parsed.responseFormat;
                 this.limit = parsed.limit;
                 this.mode = 'gui';
@@ -665,7 +651,7 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
         }
         if (this.value) {
             this.limetype = this.value.limetype || '';
-            this.filter = this.normalizeFilter(this.value.filter);
+            this.filter = this.value.filter;
             this.internalResponseFormat = this.value.responseFormat;
             this.limit = this.value.limit;
         }
@@ -680,26 +666,10 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
     render() {
         const guiSupported = this.checkGuiSupport();
         const showCodeMode = !this.guiModeEnabled || this.mode === 'code';
-        return (h("div", { key: '5ff70a352e3e57ff4c51d44627bd4b5ed367fff4', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
+        return (h("div", { key: '0b4d2bb5b4d503a775d8d3215e1e4c74fdb1eceb', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
             ? this.renderCodeMode(guiSupported)
             : this.renderGuiMode()));
     }
-    /**
-     * Normalize filter to ensure top-level is an AND group.
-     * This ensures Add buttons are available in the UI.
-     * @param filter
-     */
-    normalizeFilter(filter) {
-        if (!filter) {
-            return { op: Zt.AND, exp: [] };
-        }
-        // If it's already an AND at the top level, keep it
-        if ('op' in filter && filter.op === Zt.AND) {
-            return filter;
-        }
-        // Otherwise wrap in AND
-        return { op: Zt.AND, exp: [filter] };
-    }
     emitChange() {
         // Only emit in GUI mode
         if (this.mode === 'code') {
@@ -821,7 +791,7 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
         if (!this.limetype) {
             return;
         }
-        return (h("div", { class: "filter-section" }, h("h4", { class: "section-label" }, "Filter Conditions"), h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.filter, onExpressionChange: this.handleFilterChange })));
+        return (h("div", { class: "filter-section" }, h("h4", { class: "section-label" }, "Filter Conditions"), h("limebb-lime-query-filter-builder", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.filter, onExpressionChange: this.handleFilterChange })));
     }
     renderQueryOptionsSection() {
         var _a;
@@ -870,13 +840,18 @@ function defineCustomElement$1() {
     if (typeof customElements === "undefined") {
         return;
     }
-    const components = ["limebb-lime-query-builder", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not", "limebb-lime-query-value-input", "limebb-limetype-field", "limebb-property-selector", "limebb-response-format-editor", "limebb-response-format-item"];
+    const components = ["limebb-lime-query-builder", "limebb-lime-query-filter-builder", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not", "limebb-lime-query-value-input", "limebb-limetype-field", "limebb-property-selector", "limebb-response-format-editor", "limebb-response-format-item"];
     components.forEach(tagName => { switch (tagName) {
         case "limebb-lime-query-builder":
             if (!customElements.get(tagName)) {
                 customElements.define(tagName, LimeQueryBuilder);
             }
             break;
+        case "limebb-lime-query-filter-builder":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$b();
+            }
+            break;
         case "limebb-lime-query-filter-comparison":
             if (!customElements.get(tagName)) {
                 defineCustomElement$a();

package/dist/components/limebb-lime-query-filter-builder.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface LimebbLimeQueryFilterBuilder extends Components.LimebbLimeQueryFilterBuilder, HTMLElement {}
+export const LimebbLimeQueryFilterBuilder: {
+    prototype: LimebbLimeQueryFilterBuilder;
+    new (): LimebbLimeQueryFilterBuilder;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/limebb-lime-query-filter-builder.js

@@ -0,0 +1,6 @@
+import { L as LimeQueryFilterBuilderComponent, d as defineCustomElement$1 } from './lime-query-filter-builder.js';
+
+const LimebbLimeQueryFilterBuilder = LimeQueryFilterBuilderComponent;
+const defineCustomElement = defineCustomElement$1;
+
+export { LimebbLimeQueryFilterBuilder, defineCustomElement };