@limetech/lime-crm-building-blocks 1.96.0 → 1.98.0

package/dist/types/components.d.ts

@@ -17,10 +17,11 @@ import { DateTimeFormat, NumberFormat, RelativeDateTimeFormat } from "./componen
 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 } from "./components/lime-query-builder/lime-query.types";
+import { FilterOperator, LimeQuery, LimeQueryFilterAnd, LimeQueryFilterComparison, LimeQueryFilterExpression, LimeQueryFilterMissing, LimeQueryFilterNot, LimeQueryFilterOr, ResponseFormat } from "./components/lime-query-builder/lime-query.types";
 import { LanguagePickerType } from "./components/locale-picker/language-picker.types";
 import { NavigationButtonType } from "./components/navigation-button/navigation-button.types";
 import { NotificationItem } from "./components/notification-list/notification-item/notification-item.types";
+import { PropertySelectionItem } from "./components/lime-query-builder/property-selection-format";
 import { TriggerMap } from "./components/text-editor/text-editor.types";
 import { EnhancedEditorMetadata } from "./components/text-editor/uploader/building-blocks-upload-handler";
 export { AggregateOperator, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform } from "@limetech/lime-web-components";
@@ -35,10 +36,11 @@ export { DateTimeFormat, NumberFormat, RelativeDateTimeFormat } from "./componen
 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 } from "./components/lime-query-builder/lime-query.types";
+export { FilterOperator, LimeQuery, LimeQueryFilterAnd, LimeQueryFilterComparison, LimeQueryFilterExpression, LimeQueryFilterMissing, LimeQueryFilterNot, LimeQueryFilterOr, ResponseFormat } from "./components/lime-query-builder/lime-query.types";
 export { LanguagePickerType } from "./components/locale-picker/language-picker.types";
 export { NavigationButtonType } from "./components/navigation-button/navigation-button.types";
 export { NotificationItem } from "./components/notification-list/notification-item/notification-item.types";
+export { PropertySelectionItem } from "./components/lime-query-builder/property-selection-format";
 export { TriggerMap } from "./components/text-editor/text-editor.types";
 export { EnhancedEditorMetadata } from "./components/text-editor/uploader/building-blocks-upload-handler";
 export namespace Components {
@@ -947,19 +949,32 @@ export namespace Components {
     }
     /**
      * Lime Query Builder Component
-     * A code editor for constructing Lime Query DSL queries in JSON format.
+     * A comprehensive query builder for constructing Lime Query DSL queries.
+     * This is the main component that combines limetype selection with the filter builder.
      * Features:
-     * - **JSON code editor**: Write queries using the Lime Query DSL
-     * - **Syntax validation**: Real-time validation of query structure
-     * - **Feature flag support**: GUI mode placeholder (not yet implemented)
-     * The component allows editing of complete `LimeQuery` objects that can be sent
+     * - **Limetype selection**: Choose which object type to query
+     * - **Filter builder**: Build complex filters with AND/OR/NOT logic
+     * - **Property path selection**: Navigate through relations
+     * - **Type-aware inputs**: Automatic input types based on property type
+     * - **Response format**: Select which properties to return
+     * - **Query options**: Configure limit and other query parameters
+     * - **Placeholder support**: Use `%activeObject%` placeholders in filter values
+     * - **Real-time output**: See the Lime Query JSON as you build
+     * The component produces a complete `LimeQuery` object that can be sent
      * directly to the Lime CRM backend.
-     * When the feature flag `useLimeQueryBuilderGuiMode` is enabled, a mode toggle
-     * becomes available, but GUI mode currently shows a placeholder message.
+     * **Active Object Placeholders**:
+     * When the `activeLimetype` prop is provided, the component enables validation
+     * and UI support for `%activeObject%` placeholders in filter expressions.
+     * These placeholders reference properties of a contextual "active object"
+     * (e.g., `%activeObject%.company` references the company of the active object).
      * @exampleComponent limebb-example-lime-query-builder-basic
      * @private 
      */
     interface LimebbLimeQueryBuilder {
+        /**
+          * The limetype of the active object (for %activeObject% placeholder validation). When provided, enables placeholder validation and the placeholder input mode. When omitted, placeholders are accepted without validation.
+         */
+        "activeLimetype"?: string;
         /**
           * Component context
          */
@@ -977,6 +992,258 @@ export namespace Components {
          */
         "value": LimeQuery;
     }
+    /**
+     * Lime Query Filter AND Component
+     * Renders a group of filter expressions where **all conditions must be true**.
+     * Users can add multiple child expressions, and a record must match all of them
+     * to be included in the result set.
+     * This component displays:
+     * - A header with "All of these conditions are true" when there are multiple conditions
+     * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+     * - An "Add another condition" button to add more expressions
+     * Clicking the trash icon on a child expression removes it from the AND group.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterAnd {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * The AND expression containing child expressions
+         */
+        "expression": LimeQueryFilterAnd;
+        /**
+          * Optional label for the AND group
+         */
+        "label": string;
+        /**
+          * The limetype being queried (e.g., "deal", "company")
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Filter Comparison Component
+     * Renders a single comparison expression with three parts:
+     * 1. **Property** - The field to compare (e.g., "dealstatus", "company.name")
+     * 2. **Operator** - The comparison operator (=, !=, >, <, >=, <=, IN, ?, =?, =$)
+     * 3. **Value** - The value to compare against
+     * This is the most basic building block of a filter. Examples:
+     * - dealstatus = "won"
+     * - value > 100000
+     * - name ? "Big" (contains "Big")
+     * - dealstatus IN ["won", "tender"]
+     * The component displays:
+     * - A text input for the property (Phase 0 - will be replaced with property-path in Phase 1)
+     * - A dropdown for the operator
+     * - A value input (text/number based on operator)
+     * - A trash icon button to remove this condition
+     * @private 
+     */
+    interface LimebbLimeQueryFilterComparison {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * The comparison expression to render
+         */
+        "expression": LimeQueryFilterComparison;
+        /**
+          * Optional label for the comparison
+         */
+        "label": string;
+        /**
+          * The limetype being queried (e.g., "deal", "company")
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Filter Expression Router
+     * This is the main entry point for rendering Lime Query filters.
+     * It routes to the appropriate sub-component based on the filter type:
+     * - `'AND'` → limebb-lime-query-filter-and
+     * - `'OR'` → limebb-lime-query-filter-or
+     * - `'NOT'` → limebb-lime-query-filter-not
+     * - `'comparison'` → limebb-lime-query-filter-comparison
+     * - `''` (missing) → limebb-lime-query-filter-comparison (default)
+     * Use this component when you need to render a complete filter expression
+     * that may contain nested AND/OR/NOT logic.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterExpression {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders) Optional - used for validation and property suggestions
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * The filter expression to render
+         */
+        "expression": LimeQueryFilterExpression;
+        /**
+          * Optional label for the expression
+         */
+        "label": string;
+        /**
+          * The limetype being queried (e.g., "deal", "company") Used for property validation and type-aware inputs
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Filter NOT Component
+     * Renders a negated filter expression. This inverts the logic of the child expression,
+     * so records that would normally match will be excluded, and vice versa.
+     * For example:
+     * - NOT (status = "won") → Include all records where status is NOT "won"
+     * - NOT (value > 100000) → Include all records where value is NOT greater than 100000
+     * This component displays:
+     * - A "Not" label
+     * - A single child expression (which can be a comparison or nested AND/OR group)
+     * Clicking the trash icon removes the entire NOT expression.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterNot {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * The NOT expression containing the child expression to negate
+         */
+        "expression": LimeQueryFilterNot;
+        /**
+          * Optional label for the NOT expression
+         */
+        "label": string;
+        /**
+          * The limetype being queried (e.g., "deal", "company")
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Filter OR Component
+     * Renders a group of filter expressions where **at least one condition must be true**.
+     * Users can add multiple alternative expressions, and a record only needs to match
+     * one of them to be included in the result set.
+     * This component displays:
+     * - A header with "Any of these conditions is true" when there are multiple conditions
+     * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+     * - An "Add alternative" button to add more options
+     * Clicking the trash icon on a child expression removes it from the OR group.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterOr {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * The OR expression containing child expressions
+         */
+        "expression": LimeQueryFilterOr;
+        /**
+          * Optional label for the OR group
+         */
+        "label": string;
+        /**
+          * The limetype being queried (e.g., "deal", "company")
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+    }
+    /**
+     * Query Value Input Component
+     * Renders an appropriate input control based on the property type and operator.
+     * This component automatically adapts its UI to match the data type of the selected
+     * property, providing a better user experience and data validation.
+     * Supported input types:
+     * - **String/Text**: Standard text input field
+     * - **Integer/Decimal**: Number input with appropriate step values
+     * - **Date**: Date picker returning ISO date strings
+     * - **Time**: Time input field
+     * - **Boolean (yesno)**: True/False dropdown
+     * - **Option**: Dropdown populated with valid options from property definition
+     * - **IN operator**: Comma-separated input for multiple values (any type)
+     * - **Placeholder mode**: Select properties from active object using %activeObject%
+     * The component handles type conversions automatically:
+     * - Numbers are parsed from string inputs
+     * - Dates are converted to/from ISO strings
+     * - Booleans are converted to/from strings for dropdown compatibility
+     * @private 
+     */
+    interface LimebbLimeQueryValueInput {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * Optional label for the input
+         */
+        "label": string;
+        /**
+          * The limetype being queried
+         */
+        "limetype": string;
+        /**
+          * The operator being used
+         */
+        "operator": FilterOperator;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+        /**
+          * The property path (e.g., "dealstatus", "company.name")
+         */
+        "propertyPath": string;
+        /**
+          * The current value
+         */
+        "value": any;
+    }
     /**
      * Component for displaying the contents of an attached file on a limeobject
      * Example use case is to use it as a tab on the document card
@@ -1003,6 +1270,84 @@ export namespace Components {
          */
         "property": string;
     }
+    /**
+     * Limetype Field Component
+     * A dropdown selector for choosing a limetype (object type) from the available
+     * limetypes in the system.
+     * This component:
+     * - Displays all limetypes with their icons and localized names
+     * - Supports restricting to a specific list of limetypes
+     * - Can update dependent property-path fields when selection changes
+     * - Implements the FormComponent interface for use in forms
+     * Common use cases:
+     * - Selecting which object type to query in a lime query builder
+     * - Choosing target limetype for relations
+     * - Configuring limetype-dependent settings
+     * @private 
+     */
+    interface LimebbLimetypeField {
+        /**
+          * The context this component belongs to
+          * @inheritdoc
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * Whether or not the current property is disabled
+          * @inheritdoc
+         */
+        "disabled": boolean;
+        /**
+          * The name of this field. May be used as reference when a property mapping depends on the selected limetype.
+         */
+        "fieldName": string;
+        /**
+          * Additional contextual information about the form
+          * @inheritdoc
+         */
+        "formInfo"?: FormInfo;
+        /**
+          * The helper text for the current property
+          * @inheritdoc
+         */
+        "helperText": string;
+        /**
+          * @inheritdoc
+         */
+        "invalid": boolean;
+        /**
+          * The label of the current property
+          * @inheritdoc
+         */
+        "label": string;
+        /**
+          * The limetypes to choose from
+         */
+        "limetypes"?: string[];
+        /**
+          * Reference to the platform
+          * @inheritdoc
+         */
+        "platform": LimeWebComponentPlatform;
+        /**
+          * A list of property fields that should be updated when the selected limetype changes.
+         */
+        "propertyFields": DependentPropertyField[];
+        /**
+          * Whether or not the current property is readonly
+          * @inheritdoc
+         */
+        "readonly": boolean;
+        /**
+          * Whether or not the current property is required
+          * @inheritdoc
+         */
+        "required": boolean;
+        /**
+          * The value of the current property
+          * @inheritdoc
+         */
+        "value": string;
+    }
     /**
      * @private 
      */
@@ -1282,6 +1627,111 @@ export namespace Components {
          */
         "value": number | string;
     }
+    /**
+     * Property Selector Component
+     * A menu-based property selector that allows users to navigate through properties
+     * and relations, only emitting complete property paths (not intermediate relations).
+     * Similar to limec-context-expression but specifically for selecting properties
+     * with dot-notation paths.
+     * Features:
+     * - Menu-based navigation through properties
+     * - Submenu support for drilling into relations
+     * - Internal state management during navigation
+     * - Only emits complete paths (leaf properties)
+     * - Chip-set display showing current path
+     * @private 
+     */
+    interface LimebbPropertySelector {
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * Helper text to display
+         */
+        "helperText": string;
+        /**
+          * Label for the input
+         */
+        "label": string;
+        /**
+          * The limetype to select properties from
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+        /**
+          * Whether the field is required
+         */
+        "required": boolean;
+        /**
+          * Current complete property path value
+         */
+        "value": string;
+    }
+    /**
+     * Response Format Editor Component
+     * Allows users to select which properties should be returned in the query response.
+     * Supports selecting properties on both the main limetype and related limetypes
+     * through belongsto relations.
+     * Features:
+     * - **Property selection**: Choose properties using dropdown navigation
+     * - **Nested properties**: Select properties on related objects (e.g., company.name)
+     * - **Property aliases**: Optionally rename properties in the response
+     * - **Dynamic list**: Add/remove property selections
+     * - **Real-time updates**: Changes immediately update the responseFormat
+     * The component generates a `ResponseFormat` object with the `object` field
+     * containing the selected properties.
+     * @private 
+     */
+    interface LimebbResponseFormatEditor {
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * Optional label
+         */
+        "label": string;
+        /**
+          * The limetype to select properties from
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+        /**
+          * Current response format
+         */
+        "value": ResponseFormat;
+    }
+    /**
+     * Response Format Property Item Component
+     * Represents a single property selection with optional alias and description
+     * Part of the response format editor
+     * @private 
+     */
+    interface LimebbResponseFormatItem {
+        /**
+          * Component context
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * The property selection item
+         */
+        "item": PropertySelectionItem;
+        /**
+          * The limetype to select properties from
+         */
+        "limetype": string;
+        /**
+          * Platform service provider
+         */
+        "platform": LimeWebComponentPlatform;
+    }
     /**
      * This component uses
      * [limel-popover](https://lundalogik.github.io/lime-elements/versions/latest/#/component/limel-popover/)
@@ -1637,6 +2087,34 @@ export interface LimebbLimeQueryBuilderCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbLimeQueryBuilderElement;
 }
+export interface LimebbLimeQueryFilterAndCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimeQueryFilterAndElement;
+}
+export interface LimebbLimeQueryFilterComparisonCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimeQueryFilterComparisonElement;
+}
+export interface LimebbLimeQueryFilterExpressionCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimeQueryFilterExpressionElement;
+}
+export interface LimebbLimeQueryFilterNotCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimeQueryFilterNotElement;
+}
+export interface LimebbLimeQueryFilterOrCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimeQueryFilterOrElement;
+}
+export interface LimebbLimeQueryValueInputCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimeQueryValueInputElement;
+}
+export interface LimebbLimetypeFieldCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbLimetypeFieldElement;
+}
 export interface LimebbLoaderCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbLoaderElement;
@@ -1653,6 +2131,18 @@ export interface LimebbNotificationListCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbNotificationListElement;
 }
+export interface LimebbPropertySelectorCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbPropertySelectorElement;
+}
+export interface LimebbResponseFormatEditorCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbResponseFormatEditorElement;
+}
+export interface LimebbResponseFormatItemCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbResponseFormatItemElement;
+}
 export interface LimebbSummaryPopoverCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbSummaryPopoverElement;
@@ -2248,66 +2738,265 @@ declare global {
         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 HTMLLimebbKanbanGroupElementEventMap>(type: K, listener: (this: HTMLLimebbKanbanGroupElement, ev: LimebbKanbanGroupCustomEvent<HTMLLimebbKanbanGroupElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLLimebbKanbanGroupElementEventMap>(type: K, listener: (this: HTMLLimebbKanbanGroupElement, ev: LimebbKanbanGroupCustomEvent<HTMLLimebbKanbanGroupElementEventMap[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 HTMLLimebbKanbanGroupElement: {
+        prototype: HTMLLimebbKanbanGroupElement;
+        new (): HTMLLimebbKanbanGroupElement;
+    };
+    interface HTMLLimebbKanbanItemElementEventMap {
+        "interact": KanbanItem;
+    }
+    /**
+     * Feed item
+     * @private 
+     */
+    interface HTMLLimebbKanbanItemElement extends Components.LimebbKanbanItem, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbKanbanItemElementEventMap>(type: K, listener: (this: HTMLLimebbKanbanItemElement, ev: LimebbKanbanItemCustomEvent<HTMLLimebbKanbanItemElementEventMap[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 HTMLLimebbKanbanItemElementEventMap>(type: K, listener: (this: HTMLLimebbKanbanItemElement, ev: LimebbKanbanItemCustomEvent<HTMLLimebbKanbanItemElementEventMap[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 HTMLLimebbKanbanItemElement: {
+        prototype: HTMLLimebbKanbanItemElement;
+        new (): HTMLLimebbKanbanItemElement;
+    };
+    interface HTMLLimebbLimeQueryBuilderElementEventMap {
+        "change": LimeQuery;
+    }
+    /**
+     * Lime Query Builder Component
+     * A comprehensive query builder for constructing Lime Query DSL queries.
+     * This is the main component that combines limetype selection with the filter builder.
+     * Features:
+     * - **Limetype selection**: Choose which object type to query
+     * - **Filter builder**: Build complex filters with AND/OR/NOT logic
+     * - **Property path selection**: Navigate through relations
+     * - **Type-aware inputs**: Automatic input types based on property type
+     * - **Response format**: Select which properties to return
+     * - **Query options**: Configure limit and other query parameters
+     * - **Placeholder support**: Use `%activeObject%` placeholders in filter values
+     * - **Real-time output**: See the Lime Query JSON as you build
+     * The component produces a complete `LimeQuery` object that can be sent
+     * directly to the Lime CRM backend.
+     * **Active Object Placeholders**:
+     * When the `activeLimetype` prop is provided, the component enables validation
+     * and UI support for `%activeObject%` placeholders in filter expressions.
+     * These placeholders reference properties of a contextual "active object"
+     * (e.g., `%activeObject%.company` references the company of the active object).
+     * @exampleComponent limebb-example-lime-query-builder-basic
+     * @private 
+     */
+    interface HTMLLimebbLimeQueryBuilderElement extends Components.LimebbLimeQueryBuilder, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryBuilderElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryBuilderElement, ev: LimebbLimeQueryBuilderCustomEvent<HTMLLimebbLimeQueryBuilderElementEventMap[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 HTMLLimebbLimeQueryBuilderElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryBuilderElement, ev: LimebbLimeQueryBuilderCustomEvent<HTMLLimebbLimeQueryBuilderElementEventMap[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 HTMLLimebbLimeQueryBuilderElement: {
+        prototype: HTMLLimebbLimeQueryBuilderElement;
+        new (): HTMLLimebbLimeQueryBuilderElement;
+    };
+    interface HTMLLimebbLimeQueryFilterAndElementEventMap {
+        "expressionChange": LimeQueryFilterAnd | LimeQueryFilterMissing;
+    }
+    /**
+     * Lime Query Filter AND Component
+     * Renders a group of filter expressions where **all conditions must be true**.
+     * Users can add multiple child expressions, and a record must match all of them
+     * to be included in the result set.
+     * This component displays:
+     * - A header with "All of these conditions are true" when there are multiple conditions
+     * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+     * - An "Add another condition" button to add more expressions
+     * Clicking the trash icon on a child expression removes it from the AND group.
+     * @private 
+     */
+    interface HTMLLimebbLimeQueryFilterAndElement extends Components.LimebbLimeQueryFilterAnd, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryFilterAndElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterAndElement, ev: LimebbLimeQueryFilterAndCustomEvent<HTMLLimebbLimeQueryFilterAndElementEventMap[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 HTMLLimebbLimeQueryFilterAndElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterAndElement, ev: LimebbLimeQueryFilterAndCustomEvent<HTMLLimebbLimeQueryFilterAndElementEventMap[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 HTMLLimebbLimeQueryFilterAndElement: {
+        prototype: HTMLLimebbLimeQueryFilterAndElement;
+        new (): HTMLLimebbLimeQueryFilterAndElement;
+    };
+    interface HTMLLimebbLimeQueryFilterComparisonElementEventMap {
+        "expressionChange": LimeQueryFilterComparison | LimeQueryFilterMissing;
+    }
+    /**
+     * Lime Query Filter Comparison Component
+     * Renders a single comparison expression with three parts:
+     * 1. **Property** - The field to compare (e.g., "dealstatus", "company.name")
+     * 2. **Operator** - The comparison operator (=, !=, >, <, >=, <=, IN, ?, =?, =$)
+     * 3. **Value** - The value to compare against
+     * This is the most basic building block of a filter. Examples:
+     * - dealstatus = "won"
+     * - value > 100000
+     * - name ? "Big" (contains "Big")
+     * - dealstatus IN ["won", "tender"]
+     * The component displays:
+     * - A text input for the property (Phase 0 - will be replaced with property-path in Phase 1)
+     * - A dropdown for the operator
+     * - A value input (text/number based on operator)
+     * - A trash icon button to remove this condition
+     * @private 
+     */
+    interface HTMLLimebbLimeQueryFilterComparisonElement extends Components.LimebbLimeQueryFilterComparison, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryFilterComparisonElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterComparisonElement, ev: LimebbLimeQueryFilterComparisonCustomEvent<HTMLLimebbLimeQueryFilterComparisonElementEventMap[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 HTMLLimebbLimeQueryFilterComparisonElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterComparisonElement, ev: LimebbLimeQueryFilterComparisonCustomEvent<HTMLLimebbLimeQueryFilterComparisonElementEventMap[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 HTMLLimebbLimeQueryFilterComparisonElement: {
+        prototype: HTMLLimebbLimeQueryFilterComparisonElement;
+        new (): HTMLLimebbLimeQueryFilterComparisonElement;
+    };
+    interface HTMLLimebbLimeQueryFilterExpressionElementEventMap {
+        "expressionChange": LimeQueryFilterExpression;
+    }
+    /**
+     * Lime Query Filter Expression Router
+     * This is the main entry point for rendering Lime Query filters.
+     * It routes to the appropriate sub-component based on the filter type:
+     * - `'AND'` → limebb-lime-query-filter-and
+     * - `'OR'` → limebb-lime-query-filter-or
+     * - `'NOT'` → limebb-lime-query-filter-not
+     * - `'comparison'` → limebb-lime-query-filter-comparison
+     * - `''` (missing) → limebb-lime-query-filter-comparison (default)
+     * Use this component when you need to render a complete filter expression
+     * that may contain nested AND/OR/NOT logic.
+     * @private 
+     */
+    interface HTMLLimebbLimeQueryFilterExpressionElement extends Components.LimebbLimeQueryFilterExpression, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryFilterExpressionElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterExpressionElement, ev: LimebbLimeQueryFilterExpressionCustomEvent<HTMLLimebbLimeQueryFilterExpressionElementEventMap[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 HTMLLimebbLimeQueryFilterExpressionElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterExpressionElement, ev: LimebbLimeQueryFilterExpressionCustomEvent<HTMLLimebbLimeQueryFilterExpressionElementEventMap[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 HTMLLimebbLimeQueryFilterExpressionElement: {
+        prototype: HTMLLimebbLimeQueryFilterExpressionElement;
+        new (): HTMLLimebbLimeQueryFilterExpressionElement;
+    };
+    interface HTMLLimebbLimeQueryFilterNotElementEventMap {
+        "expressionChange": LimeQueryFilterNot | LimeQueryFilterMissing;
+    }
+    /**
+     * Lime Query Filter NOT Component
+     * Renders a negated filter expression. This inverts the logic of the child expression,
+     * so records that would normally match will be excluded, and vice versa.
+     * For example:
+     * - NOT (status = "won") → Include all records where status is NOT "won"
+     * - NOT (value > 100000) → Include all records where value is NOT greater than 100000
+     * This component displays:
+     * - A "Not" label
+     * - A single child expression (which can be a comparison or nested AND/OR group)
+     * Clicking the trash icon removes the entire NOT expression.
+     * @private 
+     */
+    interface HTMLLimebbLimeQueryFilterNotElement extends Components.LimebbLimeQueryFilterNot, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryFilterNotElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterNotElement, ev: LimebbLimeQueryFilterNotCustomEvent<HTMLLimebbLimeQueryFilterNotElementEventMap[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 HTMLLimebbLimeQueryFilterNotElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterNotElement, ev: LimebbLimeQueryFilterNotCustomEvent<HTMLLimebbLimeQueryFilterNotElementEventMap[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 HTMLLimebbKanbanGroupElement: {
-        prototype: HTMLLimebbKanbanGroupElement;
-        new (): HTMLLimebbKanbanGroupElement;
+    var HTMLLimebbLimeQueryFilterNotElement: {
+        prototype: HTMLLimebbLimeQueryFilterNotElement;
+        new (): HTMLLimebbLimeQueryFilterNotElement;
     };
-    interface HTMLLimebbKanbanItemElementEventMap {
-        "interact": KanbanItem;
+    interface HTMLLimebbLimeQueryFilterOrElementEventMap {
+        "expressionChange": LimeQueryFilterOr | LimeQueryFilterMissing;
     }
     /**
-     * Feed item
+     * Lime Query Filter OR Component
+     * Renders a group of filter expressions where **at least one condition must be true**.
+     * Users can add multiple alternative expressions, and a record only needs to match
+     * one of them to be included in the result set.
+     * This component displays:
+     * - A header with "Any of these conditions is true" when there are multiple conditions
+     * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+     * - An "Add alternative" button to add more options
+     * Clicking the trash icon on a child expression removes it from the OR group.
      * @private 
      */
-    interface HTMLLimebbKanbanItemElement extends Components.LimebbKanbanItem, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLLimebbKanbanItemElementEventMap>(type: K, listener: (this: HTMLLimebbKanbanItemElement, ev: LimebbKanbanItemCustomEvent<HTMLLimebbKanbanItemElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    interface HTMLLimebbLimeQueryFilterOrElement extends Components.LimebbLimeQueryFilterOr, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryFilterOrElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterOrElement, ev: LimebbLimeQueryFilterOrCustomEvent<HTMLLimebbLimeQueryFilterOrElementEventMap[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 HTMLLimebbKanbanItemElementEventMap>(type: K, listener: (this: HTMLLimebbKanbanItemElement, ev: LimebbKanbanItemCustomEvent<HTMLLimebbKanbanItemElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLLimebbLimeQueryFilterOrElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryFilterOrElement, ev: LimebbLimeQueryFilterOrCustomEvent<HTMLLimebbLimeQueryFilterOrElementEventMap[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 HTMLLimebbKanbanItemElement: {
-        prototype: HTMLLimebbKanbanItemElement;
-        new (): HTMLLimebbKanbanItemElement;
+    var HTMLLimebbLimeQueryFilterOrElement: {
+        prototype: HTMLLimebbLimeQueryFilterOrElement;
+        new (): HTMLLimebbLimeQueryFilterOrElement;
     };
-    interface HTMLLimebbLimeQueryBuilderElementEventMap {
-        "change": LimeQuery;
+    interface HTMLLimebbLimeQueryValueInputElementEventMap {
+        "change": any;
     }
     /**
-     * Lime Query Builder Component
-     * A code editor for constructing Lime Query DSL queries in JSON format.
-     * Features:
-     * - **JSON code editor**: Write queries using the Lime Query DSL
-     * - **Syntax validation**: Real-time validation of query structure
-     * - **Feature flag support**: GUI mode placeholder (not yet implemented)
-     * The component allows editing of complete `LimeQuery` objects that can be sent
-     * directly to the Lime CRM backend.
-     * When the feature flag `useLimeQueryBuilderGuiMode` is enabled, a mode toggle
-     * becomes available, but GUI mode currently shows a placeholder message.
-     * @exampleComponent limebb-example-lime-query-builder-basic
+     * Query Value Input Component
+     * Renders an appropriate input control based on the property type and operator.
+     * This component automatically adapts its UI to match the data type of the selected
+     * property, providing a better user experience and data validation.
+     * Supported input types:
+     * - **String/Text**: Standard text input field
+     * - **Integer/Decimal**: Number input with appropriate step values
+     * - **Date**: Date picker returning ISO date strings
+     * - **Time**: Time input field
+     * - **Boolean (yesno)**: True/False dropdown
+     * - **Option**: Dropdown populated with valid options from property definition
+     * - **IN operator**: Comma-separated input for multiple values (any type)
+     * - **Placeholder mode**: Select properties from active object using %activeObject%
+     * The component handles type conversions automatically:
+     * - Numbers are parsed from string inputs
+     * - Dates are converted to/from ISO strings
+     * - Booleans are converted to/from strings for dropdown compatibility
      * @private 
      */
-    interface HTMLLimebbLimeQueryBuilderElement extends Components.LimebbLimeQueryBuilder, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLLimebbLimeQueryBuilderElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryBuilderElement, ev: LimebbLimeQueryBuilderCustomEvent<HTMLLimebbLimeQueryBuilderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    interface HTMLLimebbLimeQueryValueInputElement extends Components.LimebbLimeQueryValueInput, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimeQueryValueInputElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryValueInputElement, ev: LimebbLimeQueryValueInputCustomEvent<HTMLLimebbLimeQueryValueInputElementEventMap[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 HTMLLimebbLimeQueryBuilderElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryBuilderElement, ev: LimebbLimeQueryBuilderCustomEvent<HTMLLimebbLimeQueryBuilderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLLimebbLimeQueryValueInputElementEventMap>(type: K, listener: (this: HTMLLimebbLimeQueryValueInputElement, ev: LimebbLimeQueryValueInputCustomEvent<HTMLLimebbLimeQueryValueInputElementEventMap[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 HTMLLimebbLimeQueryBuilderElement: {
-        prototype: HTMLLimebbLimeQueryBuilderElement;
-        new (): HTMLLimebbLimeQueryBuilderElement;
+    var HTMLLimebbLimeQueryValueInputElement: {
+        prototype: HTMLLimebbLimeQueryValueInputElement;
+        new (): HTMLLimebbLimeQueryValueInputElement;
     };
     /**
      * Component for displaying the contents of an attached file on a limeobject
@@ -2323,6 +3012,38 @@ declare global {
         prototype: HTMLLimebbLimeobjectFileViewerElement;
         new (): HTMLLimebbLimeobjectFileViewerElement;
     };
+    interface HTMLLimebbLimetypeFieldElementEventMap {
+        "change": string;
+    }
+    /**
+     * Limetype Field Component
+     * A dropdown selector for choosing a limetype (object type) from the available
+     * limetypes in the system.
+     * This component:
+     * - Displays all limetypes with their icons and localized names
+     * - Supports restricting to a specific list of limetypes
+     * - Can update dependent property-path fields when selection changes
+     * - Implements the FormComponent interface for use in forms
+     * Common use cases:
+     * - Selecting which object type to query in a lime query builder
+     * - Choosing target limetype for relations
+     * - Configuring limetype-dependent settings
+     * @private 
+     */
+    interface HTMLLimebbLimetypeFieldElement extends Components.LimebbLimetypeField, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbLimetypeFieldElementEventMap>(type: K, listener: (this: HTMLLimebbLimetypeFieldElement, ev: LimebbLimetypeFieldCustomEvent<HTMLLimebbLimetypeFieldElementEventMap[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 HTMLLimebbLimetypeFieldElementEventMap>(type: K, listener: (this: HTMLLimebbLimetypeFieldElement, ev: LimebbLimetypeFieldCustomEvent<HTMLLimebbLimetypeFieldElementEventMap[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 HTMLLimebbLimetypeFieldElement: {
+        prototype: HTMLLimebbLimetypeFieldElement;
+        new (): HTMLLimebbLimetypeFieldElement;
+    };
     /**
      * @private 
      */
@@ -2506,6 +3227,92 @@ declare global {
         prototype: HTMLLimebbPercentageVisualizerElement;
         new (): HTMLLimebbPercentageVisualizerElement;
     };
+    interface HTMLLimebbPropertySelectorElementEventMap {
+        "change": string;
+    }
+    /**
+     * Property Selector Component
+     * A menu-based property selector that allows users to navigate through properties
+     * and relations, only emitting complete property paths (not intermediate relations).
+     * Similar to limec-context-expression but specifically for selecting properties
+     * with dot-notation paths.
+     * Features:
+     * - Menu-based navigation through properties
+     * - Submenu support for drilling into relations
+     * - Internal state management during navigation
+     * - Only emits complete paths (leaf properties)
+     * - Chip-set display showing current path
+     * @private 
+     */
+    interface HTMLLimebbPropertySelectorElement extends Components.LimebbPropertySelector, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbPropertySelectorElementEventMap>(type: K, listener: (this: HTMLLimebbPropertySelectorElement, ev: LimebbPropertySelectorCustomEvent<HTMLLimebbPropertySelectorElementEventMap[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 HTMLLimebbPropertySelectorElementEventMap>(type: K, listener: (this: HTMLLimebbPropertySelectorElement, ev: LimebbPropertySelectorCustomEvent<HTMLLimebbPropertySelectorElementEventMap[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 HTMLLimebbPropertySelectorElement: {
+        prototype: HTMLLimebbPropertySelectorElement;
+        new (): HTMLLimebbPropertySelectorElement;
+    };
+    interface HTMLLimebbResponseFormatEditorElementEventMap {
+        "change": ResponseFormat;
+    }
+    /**
+     * Response Format Editor Component
+     * Allows users to select which properties should be returned in the query response.
+     * Supports selecting properties on both the main limetype and related limetypes
+     * through belongsto relations.
+     * Features:
+     * - **Property selection**: Choose properties using dropdown navigation
+     * - **Nested properties**: Select properties on related objects (e.g., company.name)
+     * - **Property aliases**: Optionally rename properties in the response
+     * - **Dynamic list**: Add/remove property selections
+     * - **Real-time updates**: Changes immediately update the responseFormat
+     * The component generates a `ResponseFormat` object with the `object` field
+     * containing the selected properties.
+     * @private 
+     */
+    interface HTMLLimebbResponseFormatEditorElement extends Components.LimebbResponseFormatEditor, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbResponseFormatEditorElementEventMap>(type: K, listener: (this: HTMLLimebbResponseFormatEditorElement, ev: LimebbResponseFormatEditorCustomEvent<HTMLLimebbResponseFormatEditorElementEventMap[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 HTMLLimebbResponseFormatEditorElementEventMap>(type: K, listener: (this: HTMLLimebbResponseFormatEditorElement, ev: LimebbResponseFormatEditorCustomEvent<HTMLLimebbResponseFormatEditorElementEventMap[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 HTMLLimebbResponseFormatEditorElement: {
+        prototype: HTMLLimebbResponseFormatEditorElement;
+        new (): HTMLLimebbResponseFormatEditorElement;
+    };
+    interface HTMLLimebbResponseFormatItemElementEventMap {
+        "itemChange": PropertySelectionItem | null;
+    }
+    /**
+     * Response Format Property Item Component
+     * Represents a single property selection with optional alias and description
+     * Part of the response format editor
+     * @private 
+     */
+    interface HTMLLimebbResponseFormatItemElement extends Components.LimebbResponseFormatItem, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbResponseFormatItemElementEventMap>(type: K, listener: (this: HTMLLimebbResponseFormatItemElement, ev: LimebbResponseFormatItemCustomEvent<HTMLLimebbResponseFormatItemElementEventMap[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 HTMLLimebbResponseFormatItemElementEventMap>(type: K, listener: (this: HTMLLimebbResponseFormatItemElement, ev: LimebbResponseFormatItemCustomEvent<HTMLLimebbResponseFormatItemElementEventMap[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 HTMLLimebbResponseFormatItemElement: {
+        prototype: HTMLLimebbResponseFormatItemElement;
+        new (): HTMLLimebbResponseFormatItemElement;
+    };
     interface HTMLLimebbSummaryPopoverElementEventMap {
         "actionSelected": ActionBarItem;
     }
@@ -2693,7 +3500,14 @@ declare global {
         "limebb-kanban-group": HTMLLimebbKanbanGroupElement;
         "limebb-kanban-item": HTMLLimebbKanbanItemElement;
         "limebb-lime-query-builder": HTMLLimebbLimeQueryBuilderElement;
+        "limebb-lime-query-filter-and": HTMLLimebbLimeQueryFilterAndElement;
+        "limebb-lime-query-filter-comparison": HTMLLimebbLimeQueryFilterComparisonElement;
+        "limebb-lime-query-filter-expression": HTMLLimebbLimeQueryFilterExpressionElement;
+        "limebb-lime-query-filter-not": HTMLLimebbLimeQueryFilterNotElement;
+        "limebb-lime-query-filter-or": HTMLLimebbLimeQueryFilterOrElement;
+        "limebb-lime-query-value-input": HTMLLimebbLimeQueryValueInputElement;
         "limebb-limeobject-file-viewer": HTMLLimebbLimeobjectFileViewerElement;
+        "limebb-limetype-field": HTMLLimebbLimetypeFieldElement;
         "limebb-live-docs-info": HTMLLimebbLiveDocsInfoElement;
         "limebb-loader": HTMLLimebbLoaderElement;
         "limebb-locale-picker": HTMLLimebbLocalePickerElement;
@@ -2703,6 +3517,9 @@ declare global {
         "limebb-notification-item": HTMLLimebbNotificationItemElement;
         "limebb-notification-list": HTMLLimebbNotificationListElement;
         "limebb-percentage-visualizer": HTMLLimebbPercentageVisualizerElement;
+        "limebb-property-selector": HTMLLimebbPropertySelectorElement;
+        "limebb-response-format-editor": HTMLLimebbResponseFormatEditorElement;
+        "limebb-response-format-item": HTMLLimebbResponseFormatItemElement;
         "limebb-summary-popover": HTMLLimebbSummaryPopoverElement;
         "limebb-text-editor": HTMLLimebbTextEditorElement;
         "limebb-text-editor-picker": HTMLLimebbTextEditorPickerElement;
@@ -3617,130 +4434,419 @@ declare namespace LocalJSX {
          */
         "context"?: LimeWebComponentContext;
         /**
-          * List of groups to display in the kanban board. Each group contains a list of items belonging to that group.
+          * List of groups to display in the kanban board. Each group contains a list of items belonging to that group.
+         */
+        "groups"?: KanbanGroup[];
+        /**
+          * Emitted when an item is interacted with
+         */
+        "onInteract"?: (event: LimebbKanbanCustomEvent<KanbanItem>) => void;
+        /**
+          * Emitted when the load more button is clicked
+         */
+        "onLoadMore"?: (event: LimebbKanbanCustomEvent<KanbanGroup>) => void;
+        /**
+          * Reference to the platform
+          * @inheritdoc
+         */
+        "platform": LimeWebComponentPlatform;
+    }
+    /**
+     * This component generates the groups for `limebb-kanban`.
+     * @private 
+     */
+    interface LimebbKanbanGroup {
+        /**
+          * The context this component belongs to
+          * @inheritdoc
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * The title of the group, which is taken from the `groupBy` property of the `limebb-kanban` component.
+         */
+        "heading"?: string;
+        /**
+          * Description of the group
+         */
+        "help"?: string;
+        /**
+          * A unique identifier for the group.
+         */
+        "identifier"?: string;
+        /**
+          * List of items to display in the group.
+         */
+        "items"?: KanbanItem[];
+        /**
+          * True if items have not finished loading.
+         */
+        "loading"?: boolean;
+        /**
+          * Emitted when the load more button is clicked
+         */
+        "onLoadMore"?: (event: LimebbKanbanGroupCustomEvent<KanbanGroup['identifier']>) => void;
+        /**
+          * Reference to the platform
+          * @inheritdoc
+         */
+        "platform": LimeWebComponentPlatform;
+        /**
+          * The summary of the group.
+         */
+        "summary"?: string;
+        /**
+          * Total number of items available for the group. This is used to determine if the "load more" button should be displayed.
+         */
+        "totalCount"?: number;
+    }
+    /**
+     * Feed item
+     * @private 
+     */
+    interface LimebbKanbanItem {
+        /**
+          * The context this component belongs to
+          * @inheritdoc
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * The item to display in the Kanban group.
+         */
+        "item"?: KanbanItem;
+        /**
+          * Fired when clicking on the Kanban item.
+         */
+        "onInteract"?: (event: LimebbKanbanItemCustomEvent<KanbanItem>) => void;
+        /**
+          * Reference to the platform
+          * @inheritdoc
+         */
+        "platform": LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Builder Component
+     * A comprehensive query builder for constructing Lime Query DSL queries.
+     * This is the main component that combines limetype selection with the filter builder.
+     * Features:
+     * - **Limetype selection**: Choose which object type to query
+     * - **Filter builder**: Build complex filters with AND/OR/NOT logic
+     * - **Property path selection**: Navigate through relations
+     * - **Type-aware inputs**: Automatic input types based on property type
+     * - **Response format**: Select which properties to return
+     * - **Query options**: Configure limit and other query parameters
+     * - **Placeholder support**: Use `%activeObject%` placeholders in filter values
+     * - **Real-time output**: See the Lime Query JSON as you build
+     * The component produces a complete `LimeQuery` object that can be sent
+     * directly to the Lime CRM backend.
+     * **Active Object Placeholders**:
+     * When the `activeLimetype` prop is provided, the component enables validation
+     * and UI support for `%activeObject%` placeholders in filter expressions.
+     * These placeholders reference properties of a contextual "active object"
+     * (e.g., `%activeObject%.company` references the company of the active object).
+     * @exampleComponent limebb-example-lime-query-builder-basic
+     * @private 
+     */
+    interface LimebbLimeQueryBuilder {
+        /**
+          * The limetype of the active object (for %activeObject% placeholder validation). When provided, enables placeholder validation and the placeholder input mode. When omitted, placeholders are accepted without validation.
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * Optional label for the Lime Query builder
+         */
+        "label"?: string;
+        /**
+          * Emitted when the Lime Query changes
+         */
+        "onChange"?: (event: LimebbLimeQueryBuilderCustomEvent<LimeQuery>) => void;
+        /**
+          * Platform service provider
+         */
+        "platform"?: LimeWebComponentPlatform;
+        /**
+          * The complete Lime Query object
+         */
+        "value"?: LimeQuery;
+    }
+    /**
+     * Lime Query Filter AND Component
+     * Renders a group of filter expressions where **all conditions must be true**.
+     * Users can add multiple child expressions, and a record must match all of them
+     * to be included in the result set.
+     * This component displays:
+     * - A header with "All of these conditions are true" when there are multiple conditions
+     * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+     * - An "Add another condition" button to add more expressions
+     * Clicking the trash icon on a child expression removes it from the AND group.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterAnd {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * The AND expression containing child expressions
+         */
+        "expression"?: LimeQueryFilterAnd;
+        /**
+          * Optional label for the AND group
+         */
+        "label"?: string;
+        /**
+          * The limetype being queried (e.g., "deal", "company")
+         */
+        "limetype"?: string;
+        /**
+          * Emitted when the AND expression changes (expressions added/removed/modified)
+         */
+        "onExpressionChange"?: (event: LimebbLimeQueryFilterAndCustomEvent<LimeQueryFilterAnd | LimeQueryFilterMissing>) => void;
+        /**
+          * Platform service provider
+         */
+        "platform"?: LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Filter Comparison Component
+     * Renders a single comparison expression with three parts:
+     * 1. **Property** - The field to compare (e.g., "dealstatus", "company.name")
+     * 2. **Operator** - The comparison operator (=, !=, >, <, >=, <=, IN, ?, =?, =$)
+     * 3. **Value** - The value to compare against
+     * This is the most basic building block of a filter. Examples:
+     * - dealstatus = "won"
+     * - value > 100000
+     * - name ? "Big" (contains "Big")
+     * - dealstatus IN ["won", "tender"]
+     * The component displays:
+     * - A text input for the property (Phase 0 - will be replaced with property-path in Phase 1)
+     * - A dropdown for the operator
+     * - A value input (text/number based on operator)
+     * - A trash icon button to remove this condition
+     * @private 
+     */
+    interface LimebbLimeQueryFilterComparison {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * The comparison expression to render
+         */
+        "expression"?: LimeQueryFilterComparison;
+        /**
+          * Optional label for the comparison
+         */
+        "label"?: string;
+        /**
+          * The limetype being queried (e.g., "deal", "company")
+         */
+        "limetype"?: string;
+        /**
+          * Emitted when the comparison expression changes (property/operator/value modified)
+         */
+        "onExpressionChange"?: (event: LimebbLimeQueryFilterComparisonCustomEvent<LimeQueryFilterComparison | LimeQueryFilterMissing>) => void;
+        /**
+          * Platform service provider
+         */
+        "platform"?: LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Filter Expression Router
+     * This is the main entry point for rendering Lime Query filters.
+     * It routes to the appropriate sub-component based on the filter type:
+     * - `'AND'` → limebb-lime-query-filter-and
+     * - `'OR'` → limebb-lime-query-filter-or
+     * - `'NOT'` → limebb-lime-query-filter-not
+     * - `'comparison'` → limebb-lime-query-filter-comparison
+     * - `''` (missing) → limebb-lime-query-filter-comparison (default)
+     * Use this component when you need to render a complete filter expression
+     * that may contain nested AND/OR/NOT logic.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterExpression {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders) Optional - used for validation and property suggestions
+         */
+        "activeLimetype"?: string;
+        /**
+          * Component context
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * The filter expression to render
          */
-        "groups"?: KanbanGroup[];
+        "expression"?: LimeQueryFilterExpression;
         /**
-          * Emitted when an item is interacted with
+          * Optional label for the expression
          */
-        "onInteract"?: (event: LimebbKanbanCustomEvent<KanbanItem>) => void;
+        "label"?: string;
         /**
-          * Emitted when the load more button is clicked
+          * The limetype being queried (e.g., "deal", "company") Used for property validation and type-aware inputs
          */
-        "onLoadMore"?: (event: LimebbKanbanCustomEvent<KanbanGroup>) => void;
+        "limetype"?: string;
         /**
-          * Reference to the platform
-          * @inheritdoc
+          * Emitted when the filter expression changes
          */
-        "platform": LimeWebComponentPlatform;
+        "onExpressionChange"?: (event: LimebbLimeQueryFilterExpressionCustomEvent<LimeQueryFilterExpression>) => void;
+        /**
+          * Platform service provider
+         */
+        "platform"?: LimeWebComponentPlatform;
     }
     /**
-     * This component generates the groups for `limebb-kanban`.
+     * Lime Query Filter NOT Component
+     * Renders a negated filter expression. This inverts the logic of the child expression,
+     * so records that would normally match will be excluded, and vice versa.
+     * For example:
+     * - NOT (status = "won") → Include all records where status is NOT "won"
+     * - NOT (value > 100000) → Include all records where value is NOT greater than 100000
+     * This component displays:
+     * - A "Not" label
+     * - A single child expression (which can be a comparison or nested AND/OR group)
+     * Clicking the trash icon removes the entire NOT expression.
      * @private 
      */
-    interface LimebbKanbanGroup {
+    interface LimebbLimeQueryFilterNot {
         /**
-          * The context this component belongs to
-          * @inheritdoc
+          * The limetype of the active object (for %activeObject% placeholders)
          */
-        "context"?: LimeWebComponentContext;
+        "activeLimetype"?: string;
         /**
-          * The title of the group, which is taken from the `groupBy` property of the `limebb-kanban` component.
+          * Component context
          */
-        "heading"?: string;
+        "context"?: LimeWebComponentContext;
         /**
-          * Description of the group
+          * The NOT expression containing the child expression to negate
          */
-        "help"?: string;
+        "expression"?: LimeQueryFilterNot;
         /**
-          * A unique identifier for the group.
+          * Optional label for the NOT expression
          */
-        "identifier"?: string;
+        "label"?: string;
         /**
-          * List of items to display in the group.
+          * The limetype being queried (e.g., "deal", "company")
          */
-        "items"?: KanbanItem[];
+        "limetype"?: string;
         /**
-          * True if items have not finished loading.
+          * Emitted when the NOT expression changes (child expression modified or removed)
          */
-        "loading"?: boolean;
+        "onExpressionChange"?: (event: LimebbLimeQueryFilterNotCustomEvent<LimeQueryFilterNot | LimeQueryFilterMissing>) => void;
         /**
-          * Emitted when the load more button is clicked
+          * Platform service provider
          */
-        "onLoadMore"?: (event: LimebbKanbanGroupCustomEvent<KanbanGroup['identifier']>) => void;
+        "platform"?: LimeWebComponentPlatform;
+    }
+    /**
+     * Lime Query Filter OR Component
+     * Renders a group of filter expressions where **at least one condition must be true**.
+     * Users can add multiple alternative expressions, and a record only needs to match
+     * one of them to be included in the result set.
+     * This component displays:
+     * - A header with "Any of these conditions is true" when there are multiple conditions
+     * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+     * - An "Add alternative" button to add more options
+     * Clicking the trash icon on a child expression removes it from the OR group.
+     * @private 
+     */
+    interface LimebbLimeQueryFilterOr {
         /**
-          * Reference to the platform
-          * @inheritdoc
+          * The limetype of the active object (for %activeObject% placeholders)
          */
-        "platform": LimeWebComponentPlatform;
+        "activeLimetype"?: string;
         /**
-          * The summary of the group.
+          * Component context
          */
-        "summary"?: string;
+        "context"?: LimeWebComponentContext;
         /**
-          * Total number of items available for the group. This is used to determine if the "load more" button should be displayed.
+          * The OR expression containing child expressions
          */
-        "totalCount"?: number;
-    }
-    /**
-     * Feed item
-     * @private 
-     */
-    interface LimebbKanbanItem {
+        "expression"?: LimeQueryFilterOr;
         /**
-          * The context this component belongs to
-          * @inheritdoc
+          * Optional label for the OR group
          */
-        "context"?: LimeWebComponentContext;
+        "label"?: string;
         /**
-          * The item to display in the Kanban group.
+          * The limetype being queried (e.g., "deal", "company")
          */
-        "item"?: KanbanItem;
+        "limetype"?: string;
         /**
-          * Fired when clicking on the Kanban item.
+          * Emitted when the OR expression changes (expressions added/removed/modified)
          */
-        "onInteract"?: (event: LimebbKanbanItemCustomEvent<KanbanItem>) => void;
+        "onExpressionChange"?: (event: LimebbLimeQueryFilterOrCustomEvent<LimeQueryFilterOr | LimeQueryFilterMissing>) => void;
         /**
-          * Reference to the platform
-          * @inheritdoc
+          * Platform service provider
          */
-        "platform": LimeWebComponentPlatform;
+        "platform"?: LimeWebComponentPlatform;
     }
     /**
-     * Lime Query Builder Component
-     * A code editor for constructing Lime Query DSL queries in JSON format.
-     * Features:
-     * - **JSON code editor**: Write queries using the Lime Query DSL
-     * - **Syntax validation**: Real-time validation of query structure
-     * - **Feature flag support**: GUI mode placeholder (not yet implemented)
-     * The component allows editing of complete `LimeQuery` objects that can be sent
-     * directly to the Lime CRM backend.
-     * When the feature flag `useLimeQueryBuilderGuiMode` is enabled, a mode toggle
-     * becomes available, but GUI mode currently shows a placeholder message.
-     * @exampleComponent limebb-example-lime-query-builder-basic
+     * Query Value Input Component
+     * Renders an appropriate input control based on the property type and operator.
+     * This component automatically adapts its UI to match the data type of the selected
+     * property, providing a better user experience and data validation.
+     * Supported input types:
+     * - **String/Text**: Standard text input field
+     * - **Integer/Decimal**: Number input with appropriate step values
+     * - **Date**: Date picker returning ISO date strings
+     * - **Time**: Time input field
+     * - **Boolean (yesno)**: True/False dropdown
+     * - **Option**: Dropdown populated with valid options from property definition
+     * - **IN operator**: Comma-separated input for multiple values (any type)
+     * - **Placeholder mode**: Select properties from active object using %activeObject%
+     * The component handles type conversions automatically:
+     * - Numbers are parsed from string inputs
+     * - Dates are converted to/from ISO strings
+     * - Booleans are converted to/from strings for dropdown compatibility
      * @private 
      */
-    interface LimebbLimeQueryBuilder {
+    interface LimebbLimeQueryValueInput {
+        /**
+          * The limetype of the active object (for %activeObject% placeholders)
+         */
+        "activeLimetype"?: string;
         /**
           * Component context
          */
         "context"?: LimeWebComponentContext;
         /**
-          * Optional label for the Lime Query builder
+          * Optional label for the input
          */
         "label"?: string;
         /**
-          * Emitted when the Lime Query changes
+          * The limetype being queried
          */
-        "onChange"?: (event: LimebbLimeQueryBuilderCustomEvent<LimeQuery>) => void;
+        "limetype"?: string;
+        /**
+          * Emitted when the value changes
+         */
+        "onChange"?: (event: LimebbLimeQueryValueInputCustomEvent<any>) => void;
+        /**
+          * The operator being used
+         */
+        "operator"?: FilterOperator;
         /**
           * Platform service provider
          */
         "platform"?: LimeWebComponentPlatform;
         /**
-          * The complete Lime Query object
+          * The property path (e.g., "dealstatus", "company.name")
          */
-        "value"?: LimeQuery;
+        "propertyPath"?: string;
+        /**
+          * The current value
+         */
+        "value"?: any;
     }
     /**
      * Component for displaying the contents of an attached file on a limeobject
@@ -3768,6 +4874,89 @@ declare namespace LocalJSX {
          */
         "property"?: string;
     }
+    /**
+     * Limetype Field Component
+     * A dropdown selector for choosing a limetype (object type) from the available
+     * limetypes in the system.
+     * This component:
+     * - Displays all limetypes with their icons and localized names
+     * - Supports restricting to a specific list of limetypes
+     * - Can update dependent property-path fields when selection changes
+     * - Implements the FormComponent interface for use in forms
+     * Common use cases:
+     * - Selecting which object type to query in a lime query builder
+     * - Choosing target limetype for relations
+     * - Configuring limetype-dependent settings
+     * @private 
+     */
+    interface LimebbLimetypeField {
+        /**
+          * The context this component belongs to
+          * @inheritdoc
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * Whether or not the current property is disabled
+          * @inheritdoc
+         */
+        "disabled"?: boolean;
+        /**
+          * The name of this field. May be used as reference when a property mapping depends on the selected limetype.
+         */
+        "fieldName"?: string;
+        /**
+          * Additional contextual information about the form
+          * @inheritdoc
+         */
+        "formInfo"?: FormInfo;
+        /**
+          * The helper text for the current property
+          * @inheritdoc
+         */
+        "helperText"?: string;
+        /**
+          * @inheritdoc
+         */
+        "invalid"?: boolean;
+        /**
+          * The label of the current property
+          * @inheritdoc
+         */
+        "label"?: string;
+        /**
+          * The limetypes to choose from
+         */
+        "limetypes"?: string[];
+        /**
+          * The event to emit when the value of the current property has changed
+          * @inheritdoc
+         */
+        "onChange"?: (event: LimebbLimetypeFieldCustomEvent<string>) => void;
+        /**
+          * Reference to the platform
+          * @inheritdoc
+         */
+        "platform"?: LimeWebComponentPlatform;
+        /**
+          * A list of property fields that should be updated when the selected limetype changes.
+         */
+        "propertyFields"?: DependentPropertyField[];
+        /**
+          * Whether or not the current property is readonly
+          * @inheritdoc
+         */
+        "readonly"?: boolean;
+        /**
+          * Whether or not the current property is required
+          * @inheritdoc
+         */
+        "required"?: boolean;
+        /**
+          * The value of the current property
+          * @inheritdoc
+         */
+        "value"?: string;
+    }
     /**
      * @private 
      */
@@ -4064,6 +5253,123 @@ declare namespace LocalJSX {
          */
         "value"?: number | string;
     }
+    /**
+     * Property Selector Component
+     * A menu-based property selector that allows users to navigate through properties
+     * and relations, only emitting complete property paths (not intermediate relations).
+     * Similar to limec-context-expression but specifically for selecting properties
+     * with dot-notation paths.
+     * Features:
+     * - Menu-based navigation through properties
+     * - Submenu support for drilling into relations
+     * - Internal state management during navigation
+     * - Only emits complete paths (leaf properties)
+     * - Chip-set display showing current path
+     * @private 
+     */
+    interface LimebbPropertySelector {
+        /**
+          * Component context
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * Helper text to display
+         */
+        "helperText"?: string;
+        /**
+          * Label for the input
+         */
+        "label"?: string;
+        /**
+          * The limetype to select properties from
+         */
+        "limetype"?: string;
+        /**
+          * Emitted when a complete property path is selected
+         */
+        "onChange"?: (event: LimebbPropertySelectorCustomEvent<string>) => void;
+        /**
+          * Platform service provider
+         */
+        "platform"?: LimeWebComponentPlatform;
+        /**
+          * Whether the field is required
+         */
+        "required"?: boolean;
+        /**
+          * Current complete property path value
+         */
+        "value"?: string;
+    }
+    /**
+     * Response Format Editor Component
+     * Allows users to select which properties should be returned in the query response.
+     * Supports selecting properties on both the main limetype and related limetypes
+     * through belongsto relations.
+     * Features:
+     * - **Property selection**: Choose properties using dropdown navigation
+     * - **Nested properties**: Select properties on related objects (e.g., company.name)
+     * - **Property aliases**: Optionally rename properties in the response
+     * - **Dynamic list**: Add/remove property selections
+     * - **Real-time updates**: Changes immediately update the responseFormat
+     * The component generates a `ResponseFormat` object with the `object` field
+     * containing the selected properties.
+     * @private 
+     */
+    interface LimebbResponseFormatEditor {
+        /**
+          * Component context
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * Optional label
+         */
+        "label"?: string;
+        /**
+          * The limetype to select properties from
+         */
+        "limetype"?: string;
+        /**
+          * Emitted when the response format changes
+         */
+        "onChange"?: (event: LimebbResponseFormatEditorCustomEvent<ResponseFormat>) => void;
+        /**
+          * Platform service provider
+         */
+        "platform"?: LimeWebComponentPlatform;
+        /**
+          * Current response format
+         */
+        "value"?: ResponseFormat;
+    }
+    /**
+     * Response Format Property Item Component
+     * Represents a single property selection with optional alias and description
+     * Part of the response format editor
+     * @private 
+     */
+    interface LimebbResponseFormatItem {
+        /**
+          * Component context
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * The property selection item
+         */
+        "item"?: PropertySelectionItem;
+        /**
+          * The limetype to select properties from
+         */
+        "limetype"?: string;
+        /**
+          * Emitted when the item changes
+         */
+        "onItemChange"?: (event: LimebbResponseFormatItemCustomEvent<PropertySelectionItem | null>) => void;
+        /**
+          * Platform service provider
+         */
+        "platform"?: LimeWebComponentPlatform;
+    }
     /**
      * This component uses
      * [limel-popover](https://lundalogik.github.io/lime-elements/versions/latest/#/component/limel-popover/)
@@ -4383,7 +5689,14 @@ declare namespace LocalJSX {
         "limebb-kanban-group": LimebbKanbanGroup;
         "limebb-kanban-item": LimebbKanbanItem;
         "limebb-lime-query-builder": LimebbLimeQueryBuilder;
+        "limebb-lime-query-filter-and": LimebbLimeQueryFilterAnd;
+        "limebb-lime-query-filter-comparison": LimebbLimeQueryFilterComparison;
+        "limebb-lime-query-filter-expression": LimebbLimeQueryFilterExpression;
+        "limebb-lime-query-filter-not": LimebbLimeQueryFilterNot;
+        "limebb-lime-query-filter-or": LimebbLimeQueryFilterOr;
+        "limebb-lime-query-value-input": LimebbLimeQueryValueInput;
         "limebb-limeobject-file-viewer": LimebbLimeobjectFileViewer;
+        "limebb-limetype-field": LimebbLimetypeField;
         "limebb-live-docs-info": LimebbLiveDocsInfo;
         "limebb-loader": LimebbLoader;
         "limebb-locale-picker": LimebbLocalePicker;
@@ -4393,6 +5706,9 @@ declare namespace LocalJSX {
         "limebb-notification-item": LimebbNotificationItem;
         "limebb-notification-list": LimebbNotificationList;
         "limebb-percentage-visualizer": LimebbPercentageVisualizer;
+        "limebb-property-selector": LimebbPropertySelector;
+        "limebb-response-format-editor": LimebbResponseFormatEditor;
+        "limebb-response-format-item": LimebbResponseFormatItem;
         "limebb-summary-popover": LimebbSummaryPopover;
         "limebb-text-editor": LimebbTextEditor;
         "limebb-text-editor-picker": LimebbTextEditorPicker;
@@ -4675,19 +5991,122 @@ declare module "@stencil/core" {
             "limebb-kanban-item": LocalJSX.LimebbKanbanItem & JSXBase.HTMLAttributes<HTMLLimebbKanbanItemElement>;
             /**
              * Lime Query Builder Component
-             * A code editor for constructing Lime Query DSL queries in JSON format.
+             * A comprehensive query builder for constructing Lime Query DSL queries.
+             * This is the main component that combines limetype selection with the filter builder.
              * Features:
-             * - **JSON code editor**: Write queries using the Lime Query DSL
-             * - **Syntax validation**: Real-time validation of query structure
-             * - **Feature flag support**: GUI mode placeholder (not yet implemented)
-             * The component allows editing of complete `LimeQuery` objects that can be sent
+             * - **Limetype selection**: Choose which object type to query
+             * - **Filter builder**: Build complex filters with AND/OR/NOT logic
+             * - **Property path selection**: Navigate through relations
+             * - **Type-aware inputs**: Automatic input types based on property type
+             * - **Response format**: Select which properties to return
+             * - **Query options**: Configure limit and other query parameters
+             * - **Placeholder support**: Use `%activeObject%` placeholders in filter values
+             * - **Real-time output**: See the Lime Query JSON as you build
+             * The component produces a complete `LimeQuery` object that can be sent
              * directly to the Lime CRM backend.
-             * When the feature flag `useLimeQueryBuilderGuiMode` is enabled, a mode toggle
-             * becomes available, but GUI mode currently shows a placeholder message.
+             * **Active Object Placeholders**:
+             * When the `activeLimetype` prop is provided, the component enables validation
+             * and UI support for `%activeObject%` placeholders in filter expressions.
+             * These placeholders reference properties of a contextual "active object"
+             * (e.g., `%activeObject%.company` references the company of the active object).
              * @exampleComponent limebb-example-lime-query-builder-basic
              * @private 
              */
             "limebb-lime-query-builder": LocalJSX.LimebbLimeQueryBuilder & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryBuilderElement>;
+            /**
+             * Lime Query Filter AND Component
+             * Renders a group of filter expressions where **all conditions must be true**.
+             * Users can add multiple child expressions, and a record must match all of them
+             * to be included in the result set.
+             * This component displays:
+             * - A header with "All of these conditions are true" when there are multiple conditions
+             * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+             * - An "Add another condition" button to add more expressions
+             * Clicking the trash icon on a child expression removes it from the AND group.
+             * @private 
+             */
+            "limebb-lime-query-filter-and": LocalJSX.LimebbLimeQueryFilterAnd & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterAndElement>;
+            /**
+             * Lime Query Filter Comparison Component
+             * Renders a single comparison expression with three parts:
+             * 1. **Property** - The field to compare (e.g., "dealstatus", "company.name")
+             * 2. **Operator** - The comparison operator (=, !=, >, <, >=, <=, IN, ?, =?, =$)
+             * 3. **Value** - The value to compare against
+             * This is the most basic building block of a filter. Examples:
+             * - dealstatus = "won"
+             * - value > 100000
+             * - name ? "Big" (contains "Big")
+             * - dealstatus IN ["won", "tender"]
+             * The component displays:
+             * - A text input for the property (Phase 0 - will be replaced with property-path in Phase 1)
+             * - A dropdown for the operator
+             * - A value input (text/number based on operator)
+             * - A trash icon button to remove this condition
+             * @private 
+             */
+            "limebb-lime-query-filter-comparison": LocalJSX.LimebbLimeQueryFilterComparison & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterComparisonElement>;
+            /**
+             * Lime Query Filter Expression Router
+             * This is the main entry point for rendering Lime Query filters.
+             * It routes to the appropriate sub-component based on the filter type:
+             * - `'AND'` → limebb-lime-query-filter-and
+             * - `'OR'` → limebb-lime-query-filter-or
+             * - `'NOT'` → limebb-lime-query-filter-not
+             * - `'comparison'` → limebb-lime-query-filter-comparison
+             * - `''` (missing) → limebb-lime-query-filter-comparison (default)
+             * Use this component when you need to render a complete filter expression
+             * that may contain nested AND/OR/NOT logic.
+             * @private 
+             */
+            "limebb-lime-query-filter-expression": LocalJSX.LimebbLimeQueryFilterExpression & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterExpressionElement>;
+            /**
+             * Lime Query Filter NOT Component
+             * Renders a negated filter expression. This inverts the logic of the child expression,
+             * so records that would normally match will be excluded, and vice versa.
+             * For example:
+             * - NOT (status = "won") → Include all records where status is NOT "won"
+             * - NOT (value > 100000) → Include all records where value is NOT greater than 100000
+             * This component displays:
+             * - A "Not" label
+             * - A single child expression (which can be a comparison or nested AND/OR group)
+             * Clicking the trash icon removes the entire NOT expression.
+             * @private 
+             */
+            "limebb-lime-query-filter-not": LocalJSX.LimebbLimeQueryFilterNot & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterNotElement>;
+            /**
+             * Lime Query Filter OR Component
+             * Renders a group of filter expressions where **at least one condition must be true**.
+             * Users can add multiple alternative expressions, and a record only needs to match
+             * one of them to be included in the result set.
+             * This component displays:
+             * - A header with "Any of these conditions is true" when there are multiple conditions
+             * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+             * - An "Add alternative" button to add more options
+             * Clicking the trash icon on a child expression removes it from the OR group.
+             * @private 
+             */
+            "limebb-lime-query-filter-or": LocalJSX.LimebbLimeQueryFilterOr & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryFilterOrElement>;
+            /**
+             * Query Value Input Component
+             * Renders an appropriate input control based on the property type and operator.
+             * This component automatically adapts its UI to match the data type of the selected
+             * property, providing a better user experience and data validation.
+             * Supported input types:
+             * - **String/Text**: Standard text input field
+             * - **Integer/Decimal**: Number input with appropriate step values
+             * - **Date**: Date picker returning ISO date strings
+             * - **Time**: Time input field
+             * - **Boolean (yesno)**: True/False dropdown
+             * - **Option**: Dropdown populated with valid options from property definition
+             * - **IN operator**: Comma-separated input for multiple values (any type)
+             * - **Placeholder mode**: Select properties from active object using %activeObject%
+             * The component handles type conversions automatically:
+             * - Numbers are parsed from string inputs
+             * - Dates are converted to/from ISO strings
+             * - Booleans are converted to/from strings for dropdown compatibility
+             * @private 
+             */
+            "limebb-lime-query-value-input": LocalJSX.LimebbLimeQueryValueInput & JSXBase.HTMLAttributes<HTMLLimebbLimeQueryValueInputElement>;
             /**
              * Component for displaying the contents of an attached file on a limeobject
              * Example use case is to use it as a tab on the document card
@@ -4697,6 +6116,22 @@ declare module "@stencil/core" {
              * @beta 
              */
             "limebb-limeobject-file-viewer": LocalJSX.LimebbLimeobjectFileViewer & JSXBase.HTMLAttributes<HTMLLimebbLimeobjectFileViewerElement>;
+            /**
+             * Limetype Field Component
+             * A dropdown selector for choosing a limetype (object type) from the available
+             * limetypes in the system.
+             * This component:
+             * - Displays all limetypes with their icons and localized names
+             * - Supports restricting to a specific list of limetypes
+             * - Can update dependent property-path fields when selection changes
+             * - Implements the FormComponent interface for use in forms
+             * Common use cases:
+             * - Selecting which object type to query in a lime query builder
+             * - Choosing target limetype for relations
+             * - Configuring limetype-dependent settings
+             * @private 
+             */
+            "limebb-limetype-field": LocalJSX.LimebbLimetypeField & JSXBase.HTMLAttributes<HTMLLimebbLimetypeFieldElement>;
             /**
              * @private 
              */
@@ -4791,6 +6226,44 @@ declare module "@stencil/core" {
              * @beta 
              */
             "limebb-percentage-visualizer": LocalJSX.LimebbPercentageVisualizer & JSXBase.HTMLAttributes<HTMLLimebbPercentageVisualizerElement>;
+            /**
+             * Property Selector Component
+             * A menu-based property selector that allows users to navigate through properties
+             * and relations, only emitting complete property paths (not intermediate relations).
+             * Similar to limec-context-expression but specifically for selecting properties
+             * with dot-notation paths.
+             * Features:
+             * - Menu-based navigation through properties
+             * - Submenu support for drilling into relations
+             * - Internal state management during navigation
+             * - Only emits complete paths (leaf properties)
+             * - Chip-set display showing current path
+             * @private 
+             */
+            "limebb-property-selector": LocalJSX.LimebbPropertySelector & JSXBase.HTMLAttributes<HTMLLimebbPropertySelectorElement>;
+            /**
+             * Response Format Editor Component
+             * Allows users to select which properties should be returned in the query response.
+             * Supports selecting properties on both the main limetype and related limetypes
+             * through belongsto relations.
+             * Features:
+             * - **Property selection**: Choose properties using dropdown navigation
+             * - **Nested properties**: Select properties on related objects (e.g., company.name)
+             * - **Property aliases**: Optionally rename properties in the response
+             * - **Dynamic list**: Add/remove property selections
+             * - **Real-time updates**: Changes immediately update the responseFormat
+             * The component generates a `ResponseFormat` object with the `object` field
+             * containing the selected properties.
+             * @private 
+             */
+            "limebb-response-format-editor": LocalJSX.LimebbResponseFormatEditor & JSXBase.HTMLAttributes<HTMLLimebbResponseFormatEditorElement>;
+            /**
+             * Response Format Property Item Component
+             * Represents a single property selection with optional alias and description
+             * Part of the response format editor
+             * @private 
+             */
+            "limebb-response-format-item": LocalJSX.LimebbResponseFormatItem & JSXBase.HTMLAttributes<HTMLLimebbResponseFormatItemElement>;
             /**
              * This component uses
              * [limel-popover](https://lundalogik.github.io/lime-elements/versions/latest/#/component/limel-popover/)