@limetech/lime-crm-building-blocks 1.100.1 → 1.102.0

package/dist/collection/components/lime-query-builder/order-by/order-by-editor.js

@@ -0,0 +1,252 @@
+import { h, } from "@stencil/core";
+/**
+ * Order By Editor Component
+ *
+ * Allows users to specify the order in which query results should be sorted.
+ * Supports sorting by multiple properties with ascending or descending order.
+ *
+ * Features:
+ * - **Property selection**: Choose properties using dropdown navigation
+ * - **Sort direction**: Toggle between ascending (ASC) and descending (DESC)
+ * - **Multiple sort fields**: Add multiple properties to create complex sorting
+ * - **Order matters**: Properties are sorted in the order they appear in the list
+ * - **Dynamic list**: Add/remove sort fields
+ *
+ * The component generates an `OrderByItem[]` array where each item specifies
+ * a property path and sort direction.
+ *
+ * @private
+ */
+export class OrderByEditor {
+    constructor() {
+        /**
+         * Optional label
+         */
+        this.label = 'Sort Order';
+        this.items = [];
+        this.handleItemChange = (index) => (event) => {
+            event.stopPropagation();
+            const newItems = [...this.items];
+            if (event.detail === null) {
+                // Remove item
+                newItems.splice(index, 1);
+            }
+            else {
+                // Update item
+                newItems[index] = event.detail;
+            }
+            this.items = newItems;
+            this.emitChange();
+        };
+        this.handleAddSortField = () => {
+            // Add new item with empty path and ASC direction
+            this.items = [...this.items, { '': 'ASC' }];
+            this.emitChange();
+        };
+    }
+    componentWillLoad() {
+        if (this.value && this.value.length > 0) {
+            this.items = [...this.value];
+        }
+    }
+    handleValueChange(newValue) {
+        if (!newValue) {
+            return;
+        }
+        // Check if items have changed
+        const itemsChanged = newValue.length !== this.items.length ||
+            !newValue.every((item, index) => {
+                const currentItem = this.items[index];
+                if (!currentItem)
+                    return false;
+                const itemKey = Object.keys(item)[0];
+                const currentKey = Object.keys(currentItem)[0];
+                return (itemKey === currentKey &&
+                    item[itemKey] === currentItem[currentKey]);
+            });
+        if (itemsChanged) {
+            this.items = newValue.length > 0 ? [...newValue] : [];
+        }
+    }
+    render() {
+        if (!this.limetype) {
+            return (h("div", { class: "empty-state" }, h("p", null, "Select a limetype to configure sorting")));
+        }
+        return (h("div", { class: "order-by-editor" }, h("div", { class: "header" }, h("h4", null, this.label)), this.renderOrderByList(), this.renderActions()));
+    }
+    renderOrderByList() {
+        if (this.items.length === 0) {
+            return null;
+        }
+        return (h("div", { class: "order-by-list" }, this.items.map((item, index) => this.renderItem(item, index))));
+    }
+    renderActions() {
+        return (h("div", { class: "actions" }, h("limel-button", { label: "Add Sort Field", icon: "plus_math", onClick: this.handleAddSortField })));
+    }
+    renderItem(item, index) {
+        const propertyPath = Object.keys(item)[0] || '';
+        return (h("limebb-lime-query-order-by-item", { key: `${propertyPath}-${index}`, class: "order-by-item", platform: this.platform, context: this.context, limetype: this.limetype, item: item, onItemChange: this.handleItemChange(index) }));
+    }
+    emitChange() {
+        this.change.emit(this.items);
+    }
+    static get is() { return "limebb-lime-query-order-by-editor"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["order-by-editor.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["order-by-editor.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 to select properties from"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "limetype",
+                "reflect": false
+            },
+            "value": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "OrderByItem[]",
+                    "resolved": "OrderByItem[] | undefined",
+                    "references": {
+                        "OrderByItem": {
+                            "location": "import",
+                            "path": "../lime-query.types",
+                            "id": "src/components/lime-query-builder/lime-query.types.ts::OrderByItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Current order by specification"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional label"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "label",
+                "reflect": false,
+                "defaultValue": "'Sort Order'"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "items": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "change",
+                "name": "change",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted when the order by specification changes"
+                },
+                "complexType": {
+                    "original": "OrderByItem[]",
+                    "resolved": "OrderByItem[]",
+                    "references": {
+                        "OrderByItem": {
+                            "location": "import",
+                            "path": "../lime-query.types",
+                            "id": "src/components/lime-query-builder/lime-query.types.ts::OrderByItem"
+                        }
+                    }
+                }
+            }];
+    }
+    static get watchers() {
+        return [{
+                "propName": "value",
+                "methodName": "handleValueChange"
+            }];
+    }
+}

package/dist/collection/components/lime-query-builder/order-by/order-by-item.css

@@ -0,0 +1,45 @@
+:host(limebb-lime-query-order-by-item) {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  width: 100%;
+}
+
+.order-by-controls {
+  display: flex;
+  flex-direction: row;
+  align-items: flex-start;
+  gap: 0.5rem;
+  width: 100%;
+}
+
+.property-path {
+  flex-grow: 1;
+  min-width: min(20rem, 100%);
+}
+
+.control-buttons {
+  flex-shrink: 0;
+  display: flex;
+  flex-direction: row;
+  gap: 0.25rem;
+  align-items: center;
+  padding-top: 0.5rem;
+}
+.control-buttons limel-icon-button {
+  opacity: 0.6;
+  transition: opacity 0.2s ease;
+}
+.control-buttons limel-icon-button:hover {
+  opacity: 1;
+}
+
+@media (max-width: 768px) {
+  .order-by-controls {
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+  .control-buttons {
+    padding-top: 0;
+  }
+}

package/dist/collection/components/lime-query-builder/order-by/order-by-item.js

@@ -0,0 +1,173 @@
+import { h } from "@stencil/core";
+/**
+ * Order By Item Component
+ *
+ * Represents a single order by specification with property selection and direction toggle
+ * Part of the order by editor
+ * @private
+ */
+export class OrderByItemComponent {
+    constructor() {
+        this.handlePathChange = (event) => {
+            event.stopPropagation();
+            const newPath = event.detail;
+            if (!newPath) {
+                // If path is cleared, keep the current item but with empty path
+                const currentDirection = this.item[Object.keys(this.item)[0]] || 'ASC';
+                this.itemChange.emit({ '': currentDirection });
+                return;
+            }
+            // Get current direction
+            const currentPath = Object.keys(this.item)[0];
+            const currentDirection = this.item[currentPath] || 'ASC';
+            // Create new item with new path but same direction
+            const newItem = { [newPath]: currentDirection };
+            this.itemChange.emit(newItem);
+        };
+        this.handleToggleDirection = () => {
+            const propertyPath = Object.keys(this.item)[0] || '';
+            const currentDirection = this.item[propertyPath] || 'ASC';
+            const newDirection = currentDirection === 'ASC' ? 'DESC' : 'ASC';
+            const newItem = { [propertyPath]: newDirection };
+            this.itemChange.emit(newItem);
+        };
+        this.handleRemove = () => {
+            this.itemChange.emit(null);
+        };
+    }
+    render() {
+        const propertyPath = Object.keys(this.item)[0] || '';
+        const direction = this.item[propertyPath] || 'ASC';
+        return (h("div", { key: '1587617d84be8905a858059ea966b7a9e0d6df78', class: "order-by-controls" }, h("div", { key: '8d4f47423c56cad20e91142f82a5726a7325233b', class: "property-path" }, h("limebb-property-selector", { key: '42c54528d2d2ee72e5b3f6ca4b31eb7bbcb9b325', platform: this.platform, context: this.context, limetype: this.limetype, label: "Property", value: propertyPath, required: true, onChange: this.handlePathChange })), h("div", { key: '1011a34f626c94608a926567e464d380faded349', class: "control-buttons" }, h("limel-icon-button", { key: '510a7c333397792a66f3e17a3501f2af96183db9', icon: direction === 'ASC'
+                ? 'sort_ascending'
+                : 'sort_descending', label: direction === 'ASC' ? 'Ascending' : 'Descending', onClick: this.handleToggleDirection }), h("limel-icon-button", { key: '5bc160b38c565e30cca03a88d6f2d181284cefdd', icon: "trash", label: "Remove", onClick: this.handleRemove }))));
+    }
+    static get is() { return "limebb-lime-query-order-by-item"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["order-by-item.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["order-by-item.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 to select properties from"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "limetype",
+                "reflect": false
+            },
+            "item": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "OrderByItem",
+                    "resolved": "{ [propertyPath: string]: \"ASC\" | \"DESC\"; }",
+                    "references": {
+                        "OrderByItem": {
+                            "location": "import",
+                            "path": "../lime-query.types",
+                            "id": "src/components/lime-query-builder/lime-query.types.ts::OrderByItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The order by item (e.g., { \"company.name\": \"ASC\" })"
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "itemChange",
+                "name": "itemChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted when the item changes or should be removed"
+                },
+                "complexType": {
+                    "original": "OrderByItem | null",
+                    "resolved": "null | { [propertyPath: string]: \"ASC\" | \"DESC\"; }",
+                    "references": {
+                        "OrderByItem": {
+                            "location": "import",
+                            "path": "../lime-query.types",
+                            "id": "src/components/lime-query-builder/lime-query.types.ts::OrderByItem"
+                        }
+                    }
+                }
+            }];
+    }
+}

package/dist/collection/components/lime-query-builder/{response-format-editor.css → response-format/response-format-editor.css}

@@ -1,4 +1,4 @@
-:host(limebb-response-format-editor) {
+:host(limebb-lime-query-response-format-editor) {
   display: block;
   width: 100%;
 }

package/dist/collection/components/lime-query-builder/{response-format-editor.js → response-format/response-format-editor.js}

@@ -1,5 +1,5 @@
 import { h } from "@stencil/core";
-import { propertySelectionToItems, itemsToPropertySelection, } from "./property-selection-format";
+import { propertySelectionToItems, itemsToPropertySelection, } from "../property-selection-format";
 /**
  * Response Format Editor Component
  *
@@ -84,7 +84,7 @@ export class ResponseFormatEditor {
         return (h("div", { class: "response-format-editor" }, h("div", { class: "header" }, h("h4", null, this.label)), h("div", { class: "property-list" }, this.items.map((item, index) => this.renderItem(item, index))), h("div", { class: "actions" }, h("limel-button", { label: "Add Property", icon: "plus_math", onClick: this.handleAddProperty })), h("div", { class: "summary" }, h("span", { class: "count" }, this.items.length, ' ', this.items.length === 1 ? 'property' : 'properties', ' ', "selected"))));
     }
     renderItem(item, index) {
-        return (h("limebb-response-format-item", { key: `${item.path}-${index}`, class: "property-item", platform: this.platform, context: this.context, limetype: this.limetype, item: item, onItemChange: this.handleItemChange(index) }));
+        return (h("limebb-lime-query-response-format-item", { key: `${item.path}-${index}`, class: "property-item", platform: this.platform, context: this.context, limetype: this.limetype, item: item, onItemChange: this.handleItemChange(index) }));
     }
     emitChange() {
         const propertySelection = itemsToPropertySelection(this.items);
@@ -93,7 +93,7 @@ export class ResponseFormatEditor {
         };
         this.change.emit(responseFormat);
     }
-    static get is() { return "limebb-response-format-editor"; }
+    static get is() { return "limebb-lime-query-response-format-editor"; }
     static get encapsulation() { return "shadow"; }
     static get originalStyleUrls() {
         return {
@@ -181,7 +181,7 @@ export class ResponseFormatEditor {
                     "references": {
                         "ResponseFormat": {
                             "location": "import",
-                            "path": "./lime-query.types",
+                            "path": "../lime-query.types",
                             "id": "src/components/lime-query-builder/lime-query.types.ts::ResponseFormat"
                         }
                     }
@@ -239,7 +239,7 @@ export class ResponseFormatEditor {
                     "references": {
                         "ResponseFormat": {
                             "location": "import",
-                            "path": "./lime-query.types",
+                            "path": "../lime-query.types",
                             "id": "src/components/lime-query-builder/lime-query.types.ts::ResponseFormat"
                         }
                     }

package/dist/collection/components/lime-query-builder/response-format/response-format-helpers.js

@@ -0,0 +1,92 @@
+/**
+ * Helper functions for working with ResponseFormat objects
+ *
+ * These utilities handle parsing, stringifying, and default values
+ * for ResponseFormat in isolation (without full LimeQuery wrapper)
+ */
+/**
+ * Parse JSON string to ResponseFormat
+ *
+ * @param json - JSON string to parse
+ * @returns Parsed ResponseFormat object
+ * @throws Error if JSON is invalid or not a ResponseFormat
+ */
+export function parseResponseFormat(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON: ${error.message}`);
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        throw new Error('Response format must be an object');
+    }
+    // Validate structure
+    const validKeys = new Set(['object', 'aggregates']);
+    const keys = Object.keys(parsed);
+    // Check for unexpected keys
+    const unexpectedKeys = keys.filter((key) => !validKeys.has(key));
+    if (unexpectedKeys.length > 0) {
+        throw new Error(`Unexpected properties in response format: ${unexpectedKeys.join(', ')}. ` +
+            `Only 'object' and 'aggregates' are allowed.`);
+    }
+    // Must have at least one of object or aggregates
+    if (!parsed.object && !parsed.aggregates) {
+        throw new Error('Response format must contain at least one of: object, aggregates');
+    }
+    return parsed;
+}
+/**
+ * Stringify ResponseFormat to JSON
+ *
+ * @param format - ResponseFormat object to stringify
+ * @returns Pretty-printed JSON string
+ */
+export function stringifyResponseFormat(format) {
+    return JSON.stringify(format, null, 2);
+}
+/**
+ * Get default ResponseFormat (just _id)
+ *
+ * @returns Default ResponseFormat with only _id selected
+ */
+export function getDefaultResponseFormat() {
+    return {
+        object: {
+            _id: null,
+        },
+    };
+}
+/**
+ * Check if a parsed JSON object is a valid ResponseFormat
+ *
+ * This is a more lenient check than parseResponseFormat - it doesn't throw,
+ * just returns a boolean with optional error message
+ *
+ * @param json - Parsed JSON object to check
+ * @returns Object with `valid` boolean and optional `error` message
+ */
+export function isValidResponseFormatStructure(json) {
+    if (json === null || typeof json !== 'object') {
+        return { valid: false, error: 'Response format must be an object' };
+    }
+    const validKeys = new Set(['object', 'aggregates']);
+    const keys = Object.keys(json);
+    // Check for unexpected keys
+    const unexpectedKeys = keys.filter((key) => !validKeys.has(key));
+    if (unexpectedKeys.length > 0) {
+        return {
+            valid: false,
+            error: `Unexpected properties: ${unexpectedKeys.join(', ')}. Only 'object' and 'aggregates' are allowed.`,
+        };
+    }
+    // Must have at least one of object or aggregates
+    if (!json.object && !json.aggregates) {
+        return {
+            valid: false,
+            error: 'Response format must contain at least one of: object, aggregates',
+        };
+    }
+    return { valid: true };
+}

package/dist/collection/components/lime-query-builder/{response-format-item.css → response-format/response-format-item.css}

@@ -1,4 +1,4 @@
-:host(limebb-response-format-item) {
+:host(limebb-lime-query-response-format-item) {
   display: flex;
   flex-direction: column;
   gap: 0.5rem;

package/dist/collection/components/lime-query-builder/{response-format-item.js → response-format/response-format-item.js}

@@ -66,12 +66,12 @@ export class ResponseFormatItem {
     }
     render() {
         return [
-            h("div", { key: '842362f9a9cfd48420409e53f0a8dc84048e383f', class: "property-controls" }, h("div", { key: '9f1b758ca0a6123e9acdff4ee4e1480b1938bb8b', class: "property-path" }, h("limebb-property-selector", { key: '3f4ca007b7131c94c57af2883638e19657e0a876', platform: this.platform, context: this.context, limetype: this.limetype, label: "Property", value: this.item.path, required: true, onChange: this.handlePathChange })), h("div", { key: 'c0141d13b1af44df29ad6502817330da6fe62283', class: "control-buttons" }, h("limel-icon-button", { key: '24aa415a1a1d91a46a251fb947fe071cd8f6e36f', icon: "add_tag", label: "Add alias", class: this.item.alias ? 'has-value' : '', onClick: this.toggleAliasInput }), h("limel-icon-button", { key: '4fa60916e5e179361c9fa6ab49fa06ce4c88ca66', icon: "comments", label: "Add description", class: this.item.description ? 'has-value' : '', onClick: this.toggleDescriptionInput }), h("limel-icon-button", { key: '03db71a330ccc905e37ffb9d8375bb6b774812b9', icon: "trash", label: "Remove property", onClick: this.handleRemove }))),
-            this.showAliasInput && (h("div", { key: 'bebaa718fd408dfdcce2f4cfe479e1b56325df86', class: "alias" }, h("limel-input-field", { key: '2a7c1e65558ef4f4892f854da04d7e083847defd', label: "Alias", value: this.item.alias || '', placeholder: "Custom property name...", onChange: this.handleAliasChange, onBlur: this.handleAliasBlur }))),
-            this.showDescriptionInput && (h("div", { key: 'b32b9b5006a9a48e44f5725f070f9bd376c8b15f', class: "description" }, h("limel-input-field", { key: '98f63d70cc77c68cbf535d33210a8d5e0c15cf72', label: "Description", value: this.item.description || '', placeholder: "Describe this property for AI...", onChange: this.handleDescriptionChange, onBlur: this.handleDescriptionBlur }))),
+            h("div", { key: 'e804c4feb61b44aeb2f141c5b5d3269a76ac9320', class: "property-controls" }, h("div", { key: 'becbf35e823b8b16df5366c099b98ce6566d514a', class: "property-path" }, h("limebb-property-selector", { key: '2b35ccefecb9dbd4d2c418566482d9903a1c0d02', platform: this.platform, context: this.context, limetype: this.limetype, label: "Property", value: this.item.path, required: true, onChange: this.handlePathChange })), h("div", { key: '1e598bbbb6df1c5e93bd4ae5f6b112a745a68df9', class: "control-buttons" }, h("limel-icon-button", { key: 'da7ec3bf553900c96149f2d762c2d40ab97d2fbd', icon: "add_tag", label: "Add alias", class: this.item.alias ? 'has-value' : '', onClick: this.toggleAliasInput }), h("limel-icon-button", { key: '3936855dd72388fc581770f561be809b4ebc0267', icon: "comments", label: "Add description", class: this.item.description ? 'has-value' : '', onClick: this.toggleDescriptionInput }), h("limel-icon-button", { key: '221a2f7399c7c781a583bc344c273f03ae181efb', icon: "trash", label: "Remove property", onClick: this.handleRemove }))),
+            this.showAliasInput && (h("div", { key: 'ddd9a21a4a83a3e8fd7d41b13c293746cf5467ae', class: "alias" }, h("limel-input-field", { key: '1c2ec668aa6d864897a57f8aebaf8b60012addb5', label: "Alias", value: this.item.alias || '', placeholder: "Custom property name...", onChange: this.handleAliasChange, onBlur: this.handleAliasBlur }))),
+            this.showDescriptionInput && (h("div", { key: 'e989a6293fb50b760e6e7e46a650f27cd44722ba', class: "description" }, h("limel-input-field", { key: '201e61a233a14d832fe450322e782d947ff7187a', label: "Description", value: this.item.description || '', placeholder: "Describe this property for AI...", onChange: this.handleDescriptionChange, onBlur: this.handleDescriptionBlur }))),
         ];
     }
-    static get is() { return "limebb-response-format-item"; }
+    static get is() { return "limebb-lime-query-response-format-item"; }
     static get encapsulation() { return "shadow"; }
     static get originalStyleUrls() {
         return {
@@ -159,7 +159,7 @@ export class ResponseFormatItem {
                     "references": {
                         "PropertySelectionItem": {
                             "location": "import",
-                            "path": "./property-selection-format",
+                            "path": "../property-selection-format",
                             "id": "src/components/lime-query-builder/property-selection-format.ts::PropertySelectionItem"
                         }
                     }
@@ -198,7 +198,7 @@ export class ResponseFormatItem {
                     "references": {
                         "PropertySelectionItem": {
                             "location": "import",
-                            "path": "./property-selection-format",
+                            "path": "../property-selection-format",
                             "id": "src/components/lime-query-builder/property-selection-format.ts::PropertySelectionItem"
                         }
                     }