@limetech/lime-crm-building-blocks 1.130.0 → 1.131.0

package/dist/types/components/lime-query-builder/expressions/filter-group-logic.d.ts

@@ -1,73 +1,75 @@
 import { AndOrExpression, Expression, Operator } from '@limetech/lime-web-components';
+export type GroupExpression = AndOrExpression | {
+    op: Operator.NOT;
+    exp: AndOrExpression;
+};
+export type Combinator = 'AND' | 'OR' | 'NOT_AND' | 'NOT_OR';
 /**
- * Result of updating a child expression in a group
+ * Identify the combinator a group expression represents. NOT-wrapped AND/OR
+ * groups are reported as NOT_AND / NOT_OR; bare AND/OR as AND/OR.
+ * @param expression
  */
-export interface UpdateChildExpressionResult {
-    /**
-     * Type of update that occurred:
-     * - 'updated': Child was updated, group continues to exist
-     * - 'removed': Last child was deleted, group should be removed
-     * - 'unwrapped': One child remains, should unwrap to that child
-     */
-    type: 'updated' | 'removed' | 'unwrapped';
-    /**
-     * The resulting expression:
-     * - For 'updated': The updated group
-     * - For 'removed': undefined
-     * - For 'unwrapped': The single remaining child
-     */
-    expression?: Expression;
-}
+export declare function getCombinator(expression: GroupExpression): Combinator;
 /**
- * Get the subheading text for a filter group based on its operator and expression count
- *
- * @param operator - The group's operator (AND or OR)
- * @param expressionCount - Number of child expressions
- * @returns Subheading text, or empty string if 0 or 1 expressions
+ * Return the inner AND/OR group, unwrapping a NOT wrapper if present.
+ * @param expression
+ */
+export declare function getInnerAndOr(expression: GroupExpression): AndOrExpression;
+/**
+ * Transform a group expression into the shape implied by the new combinator,
+ * preserving children. Use this for combinator-pill transitions.
+ * @param expression
+ * @param next
  */
-export declare function getFilterGroupSubheading(operator: Operator.AND | Operator.OR, expressionCount: number): string;
+export declare function setCombinator(expression: GroupExpression, next: Combinator): GroupExpression;
 /**
- * Create a new empty comparison expression
+ * Type predicate for bare `AND`/`OR` groups and `NOT { AND ... }` /
+ * `NOT { OR ... }` — the shapes the group component renders via its
+ * combinator pill. Bare comparisons or `NOT { NOT ... }` wrap-shapes
+ * are not group-shaped.
+ * @param expression
+ */
+export declare function isGroupShape(expression: Expression): expression is GroupExpression;
+/**
+ * Returns the expression as a `GroupExpression` when it is group-shaped,
+ * otherwise `undefined`. Lets callers route to the group component without a
+ * visible cast at the call site.
+ * @param expression
+ */
+export declare function asGroupExpression(expression: Expression): GroupExpression | undefined;
+/**
+ * Result of updating a child expression in a group.
+ * - 'updated': the group continues to exist with one or more children.
+ * - 'removed': the last child was deleted; the group itself should be removed.
  *
- * @returns A new comparison expression with empty key and value
+ * One-child groups are intentionally preserved: the user created the group on
+ * purpose, so it persists until they explicitly delete it.
+ */
+export interface UpdateChildExpressionResult {
+    type: 'updated' | 'removed';
+    expression?: Expression;
+}
+/**
+ * Create a new empty comparison expression.
  */
 export declare function createEmptyComparison(): Expression;
 /**
- * Create a new nested group with the opposite operator from the parent
- *
- * @param parentOperator - The parent group's operator
- * @returns A new group with the opposite operator and one empty comparison
+ * Create a new nested group with the opposite operator from the parent.
+ * @param parentOperator
  */
 export declare function createNestedGroup(parentOperator: Operator.AND | Operator.OR): AndOrExpression;
 /**
- * Add a new expression to a group immutably
- *
- * @param group - The existing group
- * @param newExpression - The expression to add
- * @returns A new group with the expression added to the end
+ * Add a new expression to a group immutably.
+ * @param group
+ * @param newExpression
  */
 export declare function addExpressionToGroup(group: AndOrExpression, newExpression: Expression): AndOrExpression;
 /**
- * Toggle a group's operator between AND and OR
- *
- * @param group - The group to toggle
- * @returns A new group with the toggled operator
- */
-export declare function toggleGroupOperator(group: AndOrExpression): AndOrExpression;
-/**
- * Update a child expression in a group, handling deletion and unwrapping
- *
- * This function handles three scenarios:
- * 1. Update: Replace a child expression with a new one
- * 2. Delete: Remove a child (when updatedChild is undefined)
- *    - If last child is deleted, return 'removed' (group should be deleted)
- *    - If deletion leaves one child, return 'unwrapped' (unwrap to that child)
- *    - Otherwise, return 'updated' with the remaining children
- *
- * @param group - The group containing the child
- * @param childIndex - Index of the child to update
- * @param updatedChild - The new child expression, or undefined to delete
- * @returns Result object with type and resulting expression
+ * Update or delete a child of a group, immutably. Deleting the last
+ * child returns `{ type: 'removed' }` so the caller can drop the group.
+ * @param group
+ * @param childIndex
+ * @param updatedChild
  */
 export declare function updateChildExpression(group: AndOrExpression, childIndex: number, updatedChild: Expression | undefined): UpdateChildExpressionResult;
 //# sourceMappingURL=filter-group-logic.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-comparison-editor.d.ts

@@ -0,0 +1,29 @@
+import { LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { ComparisonExpression } from './lime-query-operators';
+/**
+ * Inline editor for a single comparison expression. `shadow: true` so
+ * its stylesheet travels with the host when `limel-popover` portals it
+ * out of the parent's shadow root.
+ *
+ * @private
+ */
+export declare class LimeQueryFilterComparisonEditorComponent {
+    platform: LimeWebComponentPlatform;
+    context: LimeWebComponentContext;
+    limetype: string;
+    activeLimetype?: string;
+    expression: ComparisonExpression;
+    expressionChange: EventEmitter<ComparisonExpression>;
+    private propertySelectorEl?;
+    componentDidLoad(): void;
+    render(): any;
+    private renderPropertySelector;
+    private renderOperator;
+    private renderValueInput;
+    private handlePropertyChange;
+    private handleOperatorChange;
+    private handleValueChange;
+    private get translator();
+}
+//# sourceMappingURL=lime-query-filter-comparison-editor.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-comparison.d.ts

@@ -1,6 +1,6 @@
-import { BasicExpression, InExpression, InFilterExpression, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
 import { EventEmitter } from '../../../stencil-public-runtime';
-type ComparisonExpression = BasicExpression | InExpression | InFilterExpression;
+import { ComparisonExpression } from './lime-query-operators';
 /**
  * Lime Query Filter Comparison Component
  *
@@ -53,16 +53,19 @@ export declare class LimeQueryFilterComparisonComponent {
      * Emits undefined when the expression should be removed
      */
     expressionChange: EventEmitter<ComparisonExpression | undefined>;
+    private isOpen;
+    componentWillLoad(): void;
     render(): any;
+    private summaryText;
+    private getPropertyLabel;
+    private summaryIcon;
+    private getOperatorLabel;
+    private formatValue;
+    private handleOpen;
+    private handleClose;
     private renderHeader;
-    private renderPropertySelector;
-    private renderOperator;
-    private renderValueInput;
-    private handlePropertyChange;
-    private handleOperatorChange;
-    private handleValueChange;
+    private handleEditorChange;
     private removeExpression;
     private get translator();
 }
-export {};
 //# sourceMappingURL=lime-query-filter-comparison.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-expression.d.ts

@@ -9,6 +9,10 @@ import { Expression, LimeWebComponent, LimeWebComponentContext, LimeWebComponent
  * - `op: Operator.AND | Operator.OR` → limebb-lime-query-filter-group
  * - `op: Operator.NOT` → limebb-lime-query-filter-not
  *
+ * Uses `scoped: true` (no shadow root) so the dispatched child element
+ * participates in the parent's light DOM — that lets the parent drive
+ * its own layout off the rendered tag (e.g. `:has(limebb-lime-query-filter-group)`).
+ *
  * @private
  */
 export declare class LimeQueryFilterExpressionComponent implements LimeWebComponent {

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-group.d.ts

@@ -1,21 +1,13 @@
 import { EventEmitter } from '../../../stencil-public-runtime';
-import { Option } from '@limetech/lime-elements';
-import { AndOrExpression, Expression, LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { Expression, LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { GroupExpression } from './filter-group-logic';
 /**
  * Lime Query Filter Group Component
  *
- * Renders a group of filter expressions with AND/OR logic that can be toggled.
- * Users can click the header to toggle between "All conditions" (AND) and
- * "Any condition" (OR).
- *
- * This component displays:
- * - A clickable header showing the current logic (AND/OR)
- * - A list of child expressions (which can be comparisons or nested groups)
- * - An "Add" button to add more expressions
- *
- * Clicking the header toggles between AND and OR logic.
- * If a child component emits an ExpressionChange event with undefined, the
- * child is removed from the group.
+ * Renders a group of filter expressions with a combinator picker that selects
+ * between All, Any, Not all, and Not any. The first two map to a bare AND/OR
+ * group; the latter two wrap the same group in a NOT expression. Choosing a
+ * value re-shapes the group, preserving all children.
  *
  * @private
  */
@@ -37,30 +29,22 @@ export declare class LimeQueryFilterGroupComponent implements LimeWebComponent {
      */
     activeLimetype?: string;
     /**
-     * The group expression (AND or OR)
+     * The group expression: an AND/OR group, optionally wrapped in NOT
      */
-    expression: AndOrExpression;
-    value: Option;
-    componentWillLoad(): void;
+    expression: GroupExpression;
     /**
-     * Emitted when the group expression changes
-     * Emits undefined when expression should be removed
-     * Can emit any Expression type when unwrapping (single child)
+     * Emitted when the group expression changes.
+     * Emits undefined when the group itself should be removed.
      */
     expressionChange: EventEmitter<Expression | undefined>;
     render(): any;
-    private renderHeader;
-    private renderOperators;
-    private renderDeleteGroupButton;
-    private options;
-    private getSubheading;
     private renderChildExpression;
-    private renderAddButton;
-    private renderAddGroupButton;
+    private handleCombinatorChange;
     private handleDeleteGroup;
-    private handleToggleOperator;
     private handleAddChildExpression;
     private handleAddChildGroup;
-    private handleExpressionChange;
+    private handleChildExpressionChange;
+    private get isNegated();
+    private wrap;
 }
 //# sourceMappingURL=lime-query-filter-group.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-operators.d.ts

@@ -0,0 +1,12 @@
+import { IconName } from '@limetech/lime-elements';
+import { BasicExpression, BasicOperator, InExpression, InFilterExpression, Operator } from '@limetech/lime-web-components';
+export type ComparisonExpression = BasicExpression | InExpression | InFilterExpression;
+export type ComparisonOperator = BasicOperator | Operator.IN;
+export interface OperatorMetadata {
+    value: ComparisonOperator;
+    label: string;
+    icon?: IconName;
+    applicableTypes?: string[];
+}
+export declare const LIME_QUERY_OPERATORS: OperatorMetadata[];
+//# sourceMappingURL=lime-query-operators.d.ts.map

package/dist/types/components/lime-query-builder/property-selector/property-selector.d.ts

@@ -59,6 +59,7 @@ export declare class PropertySelector implements LimeWebComponent {
     render(): any;
     private handleChipSetWrapperClick;
     private handleChipSetFocus;
+    private handleChipSetBlur;
     private handleSelect;
     private handleNavigateMenu;
     private handleCancel;

package/dist/types/components.d.ts

@@ -6,7 +6,7 @@
  */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { AlertType } from "./components/alert-dialog/alert-dialog.types";
-import { AggregateOperator, AndOrExpression, ContextMap, ContextScope, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, Rule, RuleRef } from "@limetech/lime-web-components";
+import { AggregateOperator, ContextMap, ContextScope, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, Rule, RuleRef } from "@limetech/lime-web-components";
 import { BrowserItem } from "./components/browser/browser-item.types";
 import { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, OpenDirection } from "@limetech/lime-elements";
 import { ChatIconList } from "./components/chat-list/chat-icon-list/chat-icon-list.types";
@@ -24,6 +24,8 @@ import { InfoTile } from "./components/info-tile/info-tile";
 import { KanbanGroup } from "./components/kanban/kanban-group/kanban-group.types";
 import { KanbanItem } from "./components/kanban/kanban-item/kanban-item.types";
 import { LimeQuery, OrderByItem, ResponseFormat } from "./components/lime-query-builder/lime-query.types";
+import { ComparisonExpression } from "./components/lime-query-builder/expressions/lime-query-operators";
+import { GroupExpression } from "./components/lime-query-builder/expressions/filter-group-logic";
 import { PropertySelectionItem } from "./components/lime-query-builder/property-selection-format";
 import { LanguagePickerType } from "./components/locale-picker/language-picker.types";
 import { NavigationButtonType } from "./components/navigation-button/navigation-button.types";
@@ -32,7 +34,7 @@ import { RuleArgFilterEditorValue } from "./components/rule-editor/rule-arg-filt
 import { TriggerMap } from "./components/text-editor/text-editor.types";
 import { EnhancedEditorMetadata } from "./components/text-editor/uploader/building-blocks-upload-handler";
 export { AlertType } from "./components/alert-dialog/alert-dialog.types";
-export { AggregateOperator, AndOrExpression, ContextMap, ContextScope, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, Rule, RuleRef } from "@limetech/lime-web-components";
+export { AggregateOperator, ContextMap, ContextScope, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, Rule, RuleRef } from "@limetech/lime-web-components";
 export { BrowserItem } from "./components/browser/browser-item.types";
 export { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, OpenDirection } from "@limetech/lime-elements";
 export { ChatIconList } from "./components/chat-list/chat-icon-list/chat-icon-list.types";
@@ -50,6 +52,8 @@ export { InfoTile } from "./components/info-tile/info-tile";
 export { KanbanGroup } from "./components/kanban/kanban-group/kanban-group.types";
 export { KanbanItem } from "./components/kanban/kanban-item/kanban-item.types";
 export { LimeQuery, OrderByItem, ResponseFormat } from "./components/lime-query-builder/lime-query.types";
+export { ComparisonExpression } from "./components/lime-query-builder/expressions/lime-query-operators";
+export { GroupExpression } from "./components/lime-query-builder/expressions/filter-group-logic";
 export { PropertySelectionItem } from "./components/lime-query-builder/property-selection-format";
 export { LanguagePickerType } from "./components/locale-picker/language-picker.types";
 export { NavigationButtonType } from "./components/navigation-button/navigation-button.types";
@@ -1395,6 +1399,19 @@ export namespace Components {
          */
         "platform": LimeWebComponentPlatform;
     }
+    /**
+     * Inline editor for a single comparison expression. `shadow: true` so
+     * its stylesheet travels with the host when `limel-popover` portals it
+     * out of the parent's shadow root.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterComparisonEditor {
+        "activeLimetype"?: string;
+        "context": LimeWebComponentContext;
+        "expression": ComparisonExpression;
+        "limetype": string;
+        "platform": LimeWebComponentPlatform;
+    }
     /**
      * Lime Query Filter Expression Router
      * Router component for rendering Lime Query filter expressions.
@@ -1402,6 +1419,9 @@ export namespace Components {
      * - Has `key` property → limebb-lime-query-filter-comparison
      * - `op: Operator.AND | Operator.OR` → limebb-lime-query-filter-group
      * - `op: Operator.NOT` → limebb-lime-query-filter-not
+     * Uses `scoped: true` (no shadow root) so the dispatched child element
+     * participates in the parent's light DOM — that lets the parent drive
+     * its own layout off the rendered tag (e.g. `:has(limebb-lime-query-filter-group)`).
      * @private 
      */
     interface LimebbLimeQueryFilterExpression {
@@ -1432,16 +1452,10 @@ export namespace Components {
     }
     /**
      * Lime Query Filter Group Component
-     * Renders a group of filter expressions with AND/OR logic that can be toggled.
-     * Users can click the header to toggle between "All conditions" (AND) and
-     * "Any condition" (OR).
-     * This component displays:
-     * - A clickable header showing the current logic (AND/OR)
-     * - A list of child expressions (which can be comparisons or nested groups)
-     * - An "Add" button to add more expressions
-     * Clicking the header toggles between AND and OR logic.
-     * If a child component emits an ExpressionChange event with undefined, the
-     * child is removed from the group.
+     * Renders a group of filter expressions with a combinator picker that selects
+     * between All, Any, Not all, and Not any. The first two map to a bare AND/OR
+     * group; the latter two wrap the same group in a NOT expression. Choosing a
+     * value re-shapes the group, preserving all children.
      * @private 
      */
     interface LimebbLimeQueryFilterGroup {
@@ -1454,9 +1468,9 @@ export namespace Components {
          */
         "context": LimeWebComponentContext;
         /**
-          * The group expression (AND or OR)
+          * The group expression: an AND/OR group, optionally wrapped in NOT
          */
-        "expression": AndOrExpression;
+        "expression": GroupExpression;
         /**
           * The limetype being queried (e.g., "deal", "company")
          */
@@ -2770,6 +2784,10 @@ export interface LimebbLimeQueryFilterComparisonCustomEvent<T> extends CustomEve
     detail: T;
     target: HTMLLimebbLimeQueryFilterComparisonElement;
 }
+export interface LimebbLimeQueryFilterComparisonEditorCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimeQueryFilterComparisonEditorElement;
+}
 export interface LimebbLimeQueryFilterExpressionCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbLimeQueryFilterExpressionElement;
@@ -3788,6 +3806,29 @@ declare global {
         prototype: HTMLLimebbLimeQueryFilterComparisonElement;
         new (): HTMLLimebbLimeQueryFilterComparisonElement;
     };
+    interface HTMLLimebbLimeQueryFilterComparisonEditorElementEventMap {
+        "expressionChange": ComparisonExpression;
+    }
+    /**
+     * Inline editor for a single comparison expression. `shadow: true` so
+     * its stylesheet travels with the host when `limel-popover` portals it
+     * out of the parent's shadow root.
+     * @private 
+     */
+    interface HTMLLimebbLimeQueryFilterComparisonEditorElement extends Components.LimebbLimeQueryFilterComparisonEditor, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryFilterComparisonEditorElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterComparisonEditorElement, ev: LimebbLimeQueryFilterComparisonEditorCustomEvent<HTMLLimebbLimeQueryFilterComparisonEditorElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLLimebbLimeQueryFilterComparisonEditorElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterComparisonEditorElement, ev: LimebbLimeQueryFilterComparisonEditorCustomEvent<HTMLLimebbLimeQueryFilterComparisonEditorElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLLimebbLimeQueryFilterComparisonEditorElement: {
+        prototype: HTMLLimebbLimeQueryFilterComparisonEditorElement;
+        new (): HTMLLimebbLimeQueryFilterComparisonEditorElement;
+    };
     interface HTMLLimebbLimeQueryFilterExpressionElementEventMap {
         "expressionChange": Expression | undefined;
     }
@@ -3798,6 +3839,9 @@ declare global {
      * - Has `key` property → limebb-lime-query-filter-comparison
      * - `op: Operator.AND | Operator.OR` → limebb-lime-query-filter-group
      * - `op: Operator.NOT` → limebb-lime-query-filter-not
+     * Uses `scoped: true` (no shadow root) so the dispatched child element
+     * participates in the parent's light DOM — that lets the parent drive
+     * its own layout off the rendered tag (e.g. `:has(limebb-lime-query-filter-group)`).
      * @private 
      */
     interface HTMLLimebbLimeQueryFilterExpressionElement extends Components.LimebbLimeQueryFilterExpression, HTMLStencilElement {
@@ -3819,16 +3863,10 @@ declare global {
     }
     /**
      * Lime Query Filter Group Component
-     * Renders a group of filter expressions with AND/OR logic that can be toggled.
-     * Users can click the header to toggle between "All conditions" (AND) and
-     * "Any condition" (OR).
-     * This component displays:
-     * - A clickable header showing the current logic (AND/OR)
-     * - A list of child expressions (which can be comparisons or nested groups)
-     * - An "Add" button to add more expressions
-     * Clicking the header toggles between AND and OR logic.
-     * If a child component emits an ExpressionChange event with undefined, the
-     * child is removed from the group.
+     * Renders a group of filter expressions with a combinator picker that selects
+     * between All, Any, Not all, and Not any. The first two map to a bare AND/OR
+     * group; the latter two wrap the same group in a NOT expression. Choosing a
+     * value re-shapes the group, preserving all children.
      * @private 
      */
     interface HTMLLimebbLimeQueryFilterGroupElement extends Components.LimebbLimeQueryFilterGroup, HTMLStencilElement {
@@ -4654,6 +4692,7 @@ declare global {
         "limebb-lime-query-builder": HTMLLimebbLimeQueryBuilderElement;
         "limebb-lime-query-filter-builder": HTMLLimebbLimeQueryFilterBuilderElement;
         "limebb-lime-query-filter-comparison": HTMLLimebbLimeQueryFilterComparisonElement;
+        "limebb-lime-query-filter-comparison-editor": HTMLLimebbLimeQueryFilterComparisonEditorElement;
         "limebb-lime-query-filter-expression": HTMLLimebbLimeQueryFilterExpressionElement;
         "limebb-lime-query-filter-group": HTMLLimebbLimeQueryFilterGroupElement;
         "limebb-lime-query-filter-not": HTMLLimebbLimeQueryFilterNotElement;
@@ -6151,6 +6190,20 @@ declare namespace LocalJSX {
          */
         "platform"?: LimeWebComponentPlatform;
     }
+    /**
+     * Inline editor for a single comparison expression. `shadow: true` so
+     * its stylesheet travels with the host when `limel-popover` portals it
+     * out of the parent's shadow root.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterComparisonEditor {
+        "activeLimetype"?: string;
+        "context"?: LimeWebComponentContext;
+        "expression"?: ComparisonExpression;
+        "limetype"?: string;
+        "onExpressionChange"?: (event: LimebbLimeQueryFilterComparisonEditorCustomEvent<ComparisonExpression>) => void;
+        "platform"?: LimeWebComponentPlatform;
+    }
     /**
      * Lime Query Filter Expression Router
      * Router component for rendering Lime Query filter expressions.
@@ -6158,6 +6211,9 @@ declare namespace LocalJSX {
      * - Has `key` property → limebb-lime-query-filter-comparison
      * - `op: Operator.AND | Operator.OR` → limebb-lime-query-filter-group
      * - `op: Operator.NOT` → limebb-lime-query-filter-not
+     * Uses `scoped: true` (no shadow root) so the dispatched child element
+     * participates in the parent's light DOM — that lets the parent drive
+     * its own layout off the rendered tag (e.g. `:has(limebb-lime-query-filter-group)`).
      * @private 
      */
     interface LimebbLimeQueryFilterExpression {
@@ -6192,16 +6248,10 @@ declare namespace LocalJSX {
     }
     /**
      * Lime Query Filter Group Component
-     * Renders a group of filter expressions with AND/OR logic that can be toggled.
-     * Users can click the header to toggle between "All conditions" (AND) and
-     * "Any condition" (OR).
-     * This component displays:
-     * - A clickable header showing the current logic (AND/OR)
-     * - A list of child expressions (which can be comparisons or nested groups)
-     * - An "Add" button to add more expressions
-     * Clicking the header toggles between AND and OR logic.
-     * If a child component emits an ExpressionChange event with undefined, the
-     * child is removed from the group.
+     * Renders a group of filter expressions with a combinator picker that selects
+     * between All, Any, Not all, and Not any. The first two map to a bare AND/OR
+     * group; the latter two wrap the same group in a NOT expression. Choosing a
+     * value re-shapes the group, preserving all children.
      * @private 
      */
     interface LimebbLimeQueryFilterGroup {
@@ -6214,15 +6264,15 @@ declare namespace LocalJSX {
          */
         "context"?: LimeWebComponentContext;
         /**
-          * The group expression (AND or OR)
+          * The group expression: an AND/OR group, optionally wrapped in NOT
          */
-        "expression"?: AndOrExpression;
+        "expression"?: GroupExpression;
         /**
           * The limetype being queried (e.g., "deal", "company")
          */
         "limetype"?: string;
         /**
-          * Emitted when the group expression changes Emits undefined when expression should be removed Can emit any Expression type when unwrapping (single child)
+          * Emitted when the group expression changes. Emits undefined when the group itself should be removed.
          */
         "onExpressionChange"?: (event: LimebbLimeQueryFilterGroupCustomEvent<Expression | undefined>) => void;
         /**
@@ -7684,6 +7734,10 @@ declare namespace LocalJSX {
         "limetype": string;
         "activeLimetype": string;
     }
+    interface LimebbLimeQueryFilterComparisonEditorAttributes {
+        "limetype": string;
+        "activeLimetype": string;
+    }
     interface LimebbLimeQueryFilterExpressionAttributes {
         "label": string;
         "limetype": string;
@@ -7882,6 +7936,7 @@ declare namespace LocalJSX {
         "limebb-lime-query-builder": Omit<LimebbLimeQueryBuilder, keyof LimebbLimeQueryBuilderAttributes> & { [K in keyof LimebbLimeQueryBuilder & keyof LimebbLimeQueryBuilderAttributes]?: LimebbLimeQueryBuilder[K] } & { [K in keyof LimebbLimeQueryBuilder & keyof LimebbLimeQueryBuilderAttributes as `attr:${K}`]?: LimebbLimeQueryBuilderAttributes[K] } & { [K in keyof LimebbLimeQueryBuilder & keyof LimebbLimeQueryBuilderAttributes as `prop:${K}`]?: LimebbLimeQueryBuilder[K] };
         "limebb-lime-query-filter-builder": Omit<LimebbLimeQueryFilterBuilder, keyof LimebbLimeQueryFilterBuilderAttributes> & { [K in keyof LimebbLimeQueryFilterBuilder & keyof LimebbLimeQueryFilterBuilderAttributes]?: LimebbLimeQueryFilterBuilder[K] } & { [K in keyof LimebbLimeQueryFilterBuilder & keyof LimebbLimeQueryFilterBuilderAttributes as `attr:${K}`]?: LimebbLimeQueryFilterBuilderAttributes[K] } & { [K in keyof LimebbLimeQueryFilterBuilder & keyof LimebbLimeQueryFilterBuilderAttributes as `prop:${K}`]?: LimebbLimeQueryFilterBuilder[K] };
         "limebb-lime-query-filter-comparison": Omit<LimebbLimeQueryFilterComparison, keyof LimebbLimeQueryFilterComparisonAttributes> & { [K in keyof LimebbLimeQueryFilterComparison & keyof LimebbLimeQueryFilterComparisonAttributes]?: LimebbLimeQueryFilterComparison[K] } & { [K in keyof LimebbLimeQueryFilterComparison & keyof LimebbLimeQueryFilterComparisonAttributes as `attr:${K}`]?: LimebbLimeQueryFilterComparisonAttributes[K] } & { [K in keyof LimebbLimeQueryFilterComparison & keyof LimebbLimeQueryFilterComparisonAttributes as `prop:${K}`]?: LimebbLimeQueryFilterComparison[K] };
+        "limebb-lime-query-filter-comparison-editor": Omit<LimebbLimeQueryFilterComparisonEditor, keyof LimebbLimeQueryFilterComparisonEditorAttributes> & { [K in keyof LimebbLimeQueryFilterComparisonEditor & keyof LimebbLimeQueryFilterComparisonEditorAttributes]?: LimebbLimeQueryFilterComparisonEditor[K] } & { [K in keyof LimebbLimeQueryFilterComparisonEditor & keyof LimebbLimeQueryFilterComparisonEditorAttributes as `attr:${K}`]?: LimebbLimeQueryFilterComparisonEditorAttributes[K] } & { [K in keyof LimebbLimeQueryFilterComparisonEditor & keyof LimebbLimeQueryFilterComparisonEditorAttributes as `prop:${K}`]?: LimebbLimeQueryFilterComparisonEditor[K] };
         "limebb-lime-query-filter-expression": Omit<LimebbLimeQueryFilterExpression, keyof LimebbLimeQueryFilterExpressionAttributes> & { [K in keyof LimebbLimeQueryFilterExpression & keyof LimebbLimeQueryFilterExpressionAttributes]?: LimebbLimeQueryFilterExpression[K] } & { [K in keyof LimebbLimeQueryFilterExpression & keyof LimebbLimeQueryFilterExpressionAttributes as `attr:${K}`]?: LimebbLimeQueryFilterExpressionAttributes[K] } & { [K in keyof LimebbLimeQueryFilterExpression & keyof LimebbLimeQueryFilterExpressionAttributes as `prop:${K}`]?: LimebbLimeQueryFilterExpression[K] };
         "limebb-lime-query-filter-group": Omit<LimebbLimeQueryFilterGroup, keyof LimebbLimeQueryFilterGroupAttributes> & { [K in keyof LimebbLimeQueryFilterGroup & keyof LimebbLimeQueryFilterGroupAttributes]?: LimebbLimeQueryFilterGroup[K] } & { [K in keyof LimebbLimeQueryFilterGroup & keyof LimebbLimeQueryFilterGroupAttributes as `attr:${K}`]?: LimebbLimeQueryFilterGroupAttributes[K] } & { [K in keyof LimebbLimeQueryFilterGroup & keyof LimebbLimeQueryFilterGroupAttributes as `prop:${K}`]?: LimebbLimeQueryFilterGroup[K] };
         "limebb-lime-query-filter-not": Omit<LimebbLimeQueryFilterNot, keyof LimebbLimeQueryFilterNotAttributes> & { [K in keyof LimebbLimeQueryFilterNot & keyof LimebbLimeQueryFilterNotAttributes]?: LimebbLimeQueryFilterNot[K] } & { [K in keyof LimebbLimeQueryFilterNot & keyof LimebbLimeQueryFilterNotAttributes as `attr:${K}`]?: LimebbLimeQueryFilterNotAttributes[K] } & { [K in keyof LimebbLimeQueryFilterNot & keyof LimebbLimeQueryFilterNotAttributes as `prop:${K}`]?: LimebbLimeQueryFilterNot[K] };
@@ -8381,6 +8436,13 @@ declare module "@stencil/core" {
              * @private 
              */
             "limebb-lime-query-filter-comparison": LocalJSX.IntrinsicElements["limebb-lime-query-filter-comparison"] & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterComparisonElement>;
+            /**
+             * Inline editor for a single comparison expression. `shadow: true` so
+             * its stylesheet travels with the host when `limel-popover` portals it
+             * out of the parent's shadow root.
+             * @private 
+             */
+            "limebb-lime-query-filter-comparison-editor": LocalJSX.IntrinsicElements["limebb-lime-query-filter-comparison-editor"] & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterComparisonEditorElement>;
             /**
              * Lime Query Filter Expression Router
              * Router component for rendering Lime Query filter expressions.
@@ -8388,21 +8450,18 @@ declare module "@stencil/core" {
              * - Has `key` property → limebb-lime-query-filter-comparison
              * - `op: Operator.AND | Operator.OR` → limebb-lime-query-filter-group
              * - `op: Operator.NOT` → limebb-lime-query-filter-not
+             * Uses `scoped: true` (no shadow root) so the dispatched child element
+             * participates in the parent's light DOM — that lets the parent drive
+             * its own layout off the rendered tag (e.g. `:has(limebb-lime-query-filter-group)`).
              * @private 
              */
             "limebb-lime-query-filter-expression": LocalJSX.IntrinsicElements["limebb-lime-query-filter-expression"] & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterExpressionElement>;
             /**
              * Lime Query Filter Group Component
-             * Renders a group of filter expressions with AND/OR logic that can be toggled.
-             * Users can click the header to toggle between "All conditions" (AND) and
-             * "Any condition" (OR).
-             * This component displays:
-             * - A clickable header showing the current logic (AND/OR)
-             * - A list of child expressions (which can be comparisons or nested groups)
-             * - An "Add" button to add more expressions
-             * Clicking the header toggles between AND and OR logic.
-             * If a child component emits an ExpressionChange event with undefined, the
-             * child is removed from the group.
+             * Renders a group of filter expressions with a combinator picker that selects
+             * between All, Any, Not all, and Not any. The first two map to a bare AND/OR
+             * group; the latter two wrap the same group in a NOT expression. Choosing a
+             * value re-shapes the group, preserving all children.
              * @private 
              */
             "limebb-lime-query-filter-group": LocalJSX.IntrinsicElements["limebb-lime-query-filter-group"] & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterGroupElement>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/lime-crm-building-blocks",
-  "version": "1.130.0",
+  "version": "1.131.0",
   "description": "A home for shared components meant for use with Lime CRM",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",