@limetech/lime-crm-building-blocks 1.124.0 → 1.126.0

package/dist/types/components.d.ts

@@ -6,7 +6,7 @@
  */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { AlertType } from "./components/alert-dialog/alert-dialog.types";
-import { AggregateOperator, AndOrExpression, Expression, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, Rule, RuleScope } from "@limetech/lime-web-components";
+import { AggregateOperator, AndOrExpression, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, Rule, RuleRef, RuleScope, SubjectRegistry } from "@limetech/lime-web-components";
 import { BrowserItem } from "./components/browser/browser-item.types";
 import { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, OpenDirection } from "@limetech/lime-elements";
 import { ChatIconList } from "./components/chat-list/chat-icon-list/chat-icon-list.types";
@@ -31,7 +31,7 @@ import { NotificationItem } from "./components/notification-list/notification-it
 import { TriggerMap } from "./components/text-editor/text-editor.types";
 import { EnhancedEditorMetadata } from "./components/text-editor/uploader/building-blocks-upload-handler";
 export { AlertType } from "./components/alert-dialog/alert-dialog.types";
-export { AggregateOperator, AndOrExpression, Expression, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, Rule, RuleScope } from "@limetech/lime-web-components";
+export { AggregateOperator, AndOrExpression, Expression, JsonValue, LimeFileUrlType, LimeType, LimeWebComponentContext, LimeWebComponentPlatform, NotExpression, Operator, PrimitiveMetadata, Rule, RuleRef, RuleScope, SubjectRegistry } from "@limetech/lime-web-components";
 export { BrowserItem } from "./components/browser/browser-item.types";
 export { ActionBarItem, CustomElementDefinition, DateType, EditorUiType, FileInfo, FormInfo, Icon, IconName, Image, Languages, ListItem, ListSeparator, OpenDirection } from "@limetech/lime-elements";
 export { ChatIconList } from "./components/chat-list/chat-icon-list/chat-icon-list.types";
@@ -243,6 +243,88 @@ export namespace Components {
          */
         "platform": LimeWebComponentPlatform;
     }
+    /**
+     * Picks a color palette from the built-in color-palettes registry,
+     * and shows the palette's swatches alongside its title — both in
+     * the dropdown row and in the selected trigger area.
+     * ### When to use this picker
+     * Use it when a Lime CRM widget needs the admin to choose a set of
+     * colors purely for **visual differentiation** between items in a
+     * list. The picker's contract is "give every item a distinct, nicely
+     * harmonized color"; it does **not** assume any item-to-color
+     * mapping is meaningful. Concrete examples:
+     * - bars / slices in a chart widget
+     * - swimlanes in a kanban view
+     * - event categories in a calendar
+     * - tag chips on a list view
+     * ### When **not** to use it
+     * Don't use this picker when colors carry semantic meaning that
+     * end users must learn and rely on — e.g. _red = high priority_,
+     * _green = healthy_, _yellow = pending_. The palette's color order
+     * and contents may evolve over time (designers tweaking shades,
+     * appending new colors, retiring duplicates), so item-to-color
+     * mappings are intentionally **not** stable across releases. For
+     * status / priority / severity surfaces, encode meaning at the
+     * value level (icons, badges, labels) rather than color alone.
+     * @exampleComponent limebb-example-color-palette-picker
+     * @beta 
+     */
+    interface LimebbColorPalettePicker {
+        /**
+          * Whether or not the current property is disabled
+          * @inheritdoc
+         */
+        "disabled": boolean;
+        /**
+          * The helper text for the current property
+          * @inheritdoc
+         */
+        "helperText": string;
+        /**
+          * @inheritdoc
+         */
+        "invalid": boolean;
+        /**
+          * The label of the current property
+          * @inheritdoc
+         */
+        "label": string;
+        /**
+          * 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;
+    }
+    /**
+     * Renders a small grid of color swatches for a palette. Used as the
+     * inline preview inside [limebb-color-palette-picker](..) — both in
+     * the trigger (the currently chosen palette) and in each row of its
+     * dropdown list (so users can see the colors before picking). Pass
+     * any CSS color strings (`rgb(var(--…))`, hex, etc.).
+     * The swatches are purely decorative — they carry no semantic
+     * information beyond what the surrounding context (e.g. the picker
+     * option's text and secondary text) already provides. The component
+     * marks itself `aria-hidden` so assistive tech skips it cleanly.
+     * @exampleComponent limebb-example-color-palette-swatches
+     * @private 
+     */
+    interface LimebbColorPaletteSwatches {
+        /**
+          * Ordered list of CSS color values to render as swatches.
+          * @default []
+         */
+        "colors": string[];
+    }
     /**
      * This component must be used in a limel-form
      * where the Command ID OR component name exists in the same section as the config.
@@ -2117,6 +2199,94 @@ export namespace Components {
          */
         "value": string;
     }
+    /**
+     * Popover content for a rule-editor chip. Carries its own styles so
+     * they travel with the element when `limel-popover` portals it out of
+     * the rule-editor's shadow DOM.
+     * @private 
+     */
+    interface LimebbRuleChipPopover {
+        "context": LimeWebComponentContext;
+        /**
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * @default true
+         */
+        "isMutable": boolean;
+        /**
+          * @default false
+         */
+        "isNegated": boolean;
+        "metadata"?: PrimitiveMetadata;
+        "platform": LimeWebComponentPlatform;
+        /**
+          * @default false
+         */
+        "readonly": boolean;
+        "refNode": RuleRef;
+    }
+    /**
+     * Tree editor for {@link Rule}.
+     * Renders a `Rule` value as a tree of nodes. Lets an author pick
+     * primitive refs in `all` / `any` groups, toggle negation, delete
+     * nodes, and edit per-primitive args via the editor declared on each
+     * primitive's metadata.
+     * The component is value-in / value-out. Pass `value` and listen for
+     * `change`; persistence is the caller's concern.
+     * Pass `availableSubjects` to forward the list of subject slots the
+     * caller knows will be available where the rule runs. The component
+     * forwards it to `RuleRegistry.validate` so `missing-slot` diagnostics
+     * surface inline on the offending nodes.
+     * @exampleComponent limebb-example-rule-editor
+     * @alpha 
+     * @private 
+     */
+    interface LimebbRuleEditor {
+        /**
+          * Subject slots the caller knows will be available where the rule runs. Forwarded to the rule registry's `validate` method so `missing-slot` issues surface inline. Leave unset when the evaluation context is not known (typical for editors that target the saved-rule library).
+         */
+        "availableSubjects"?: (keyof SubjectRegistry)[];
+        /**
+          * The context describing where this component is running.  The context provides information about the current limetype and record ID (if viewing/editing a specific record). Components can use this to load relevant data and understand their operating environment.
+         */
+        "context": LimeWebComponentContext;
+        /**
+          * Whether or not the current property is disabled The mutation UI is hidden when set. The args editor is rendered with `disabled` forwarded to it.
+          * @inheritdoc
+         */
+        "disabled": boolean;
+        /**
+          * The helper text for the current property
+          * @inheritdoc
+         */
+        "helperText": string;
+        /**
+          * The label of the current property
+          * @inheritdoc
+         */
+        "label": string;
+        /**
+          * Reference to the platform service container.  Use this to access all platform services like repositories, HTTP client, command bus, navigator, and more. The platform instance is shared across all components in the same application context.
+         */
+        "platform": LimeWebComponentPlatform;
+        /**
+          * Whether or not the current property is readonly The mutation UI (delete and negate toggles, add-group button) is hidden when set. The args editor for each ref is still rendered, with `readonly` forwarded to it.
+          * @inheritdoc
+         */
+        "readonly": boolean;
+        /**
+          * Whether or not the current property is required
+          * @inheritdoc
+         */
+        "required": boolean;
+        /**
+          * The value of the current property
+          * @inheritdoc
+         */
+        "value": Rule | undefined;
+    }
     /**
      * Renders its slot only when the configured rule evaluates true.
      * Pass a {@link Rule} and the gate compiles it on load and on prop
@@ -2124,13 +2294,14 @@ export namespace Components {
      * {@link RuleRegistry} platform service.
      * @exampleComponent limebb-example-rule-gate
      * @alpha 
+     * @private 
      */
     interface LimebbRuleGate {
         "platform": LimeWebComponentPlatform;
         /**
-          * The rule to evaluate.
+          * The rule to evaluate. When unset, the gate renders its slot unconditionally — "no rule" means "no gating", which mirrors the editor's `Rule | undefined` emit contract.
          */
-        "rule": Rule;
+        "rule": Rule | undefined;
         /**
           * Optional scope override. By default the gate resolves subject values by walking up the DOM to ancestors that registered providers with the rule registry. Pass an explicit scope to bypass that walk.
          */
@@ -2463,6 +2634,10 @@ export interface LimebbBrowserCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbBrowserElement;
 }
+export interface LimebbColorPalettePickerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbColorPalettePickerElement;
+}
 export interface LimebbComponentConfigCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbComponentConfigElement;
@@ -2615,6 +2790,14 @@ export interface LimebbPropertySelectorCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbPropertySelectorElement;
 }
+export interface LimebbRuleChipPopoverCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbRuleChipPopoverElement;
+}
+export interface LimebbRuleEditorCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLLimebbRuleEditorElement;
+}
 export interface LimebbSummaryPopoverCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLLimebbSummaryPopoverElement;
@@ -2759,6 +2942,68 @@ declare global {
         prototype: HTMLLimebbChatListElement;
         new (): HTMLLimebbChatListElement;
     };
+    interface HTMLLimebbColorPalettePickerElementEventMap {
+        "change": string;
+    }
+    /**
+     * Picks a color palette from the built-in color-palettes registry,
+     * and shows the palette's swatches alongside its title — both in
+     * the dropdown row and in the selected trigger area.
+     * ### When to use this picker
+     * Use it when a Lime CRM widget needs the admin to choose a set of
+     * colors purely for **visual differentiation** between items in a
+     * list. The picker's contract is "give every item a distinct, nicely
+     * harmonized color"; it does **not** assume any item-to-color
+     * mapping is meaningful. Concrete examples:
+     * - bars / slices in a chart widget
+     * - swimlanes in a kanban view
+     * - event categories in a calendar
+     * - tag chips on a list view
+     * ### When **not** to use it
+     * Don't use this picker when colors carry semantic meaning that
+     * end users must learn and rely on — e.g. _red = high priority_,
+     * _green = healthy_, _yellow = pending_. The palette's color order
+     * and contents may evolve over time (designers tweaking shades,
+     * appending new colors, retiring duplicates), so item-to-color
+     * mappings are intentionally **not** stable across releases. For
+     * status / priority / severity surfaces, encode meaning at the
+     * value level (icons, badges, labels) rather than color alone.
+     * @exampleComponent limebb-example-color-palette-picker
+     * @beta 
+     */
+    interface HTMLLimebbColorPalettePickerElement extends Components.LimebbColorPalettePicker, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbColorPalettePickerElementEventMap>(type: K, listener: (this: HTMLLimebbColorPalettePickerElement, ev: LimebbColorPalettePickerCustomEvent<HTMLLimebbColorPalettePickerElementEventMap[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 HTMLLimebbColorPalettePickerElementEventMap>(type: K, listener: (this: HTMLLimebbColorPalettePickerElement, ev: LimebbColorPalettePickerCustomEvent<HTMLLimebbColorPalettePickerElementEventMap[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 HTMLLimebbColorPalettePickerElement: {
+        prototype: HTMLLimebbColorPalettePickerElement;
+        new (): HTMLLimebbColorPalettePickerElement;
+    };
+    /**
+     * Renders a small grid of color swatches for a palette. Used as the
+     * inline preview inside [limebb-color-palette-picker](..) — both in
+     * the trigger (the currently chosen palette) and in each row of its
+     * dropdown list (so users can see the colors before picking). Pass
+     * any CSS color strings (`rgb(var(--…))`, hex, etc.).
+     * The swatches are purely decorative — they carry no semantic
+     * information beyond what the surrounding context (e.g. the picker
+     * option's text and secondary text) already provides. The component
+     * marks itself `aria-hidden` so assistive tech skips it cleanly.
+     * @exampleComponent limebb-example-color-palette-swatches
+     * @private 
+     */
+    interface HTMLLimebbColorPaletteSwatchesElement extends Components.LimebbColorPaletteSwatches, HTMLStencilElement {
+    }
+    var HTMLLimebbColorPaletteSwatchesElement: {
+        prototype: HTMLLimebbColorPaletteSwatchesElement;
+        new (): HTMLLimebbColorPaletteSwatchesElement;
+    };
     interface HTMLLimebbComponentConfigElementEventMap {
         "change": Record<string, unknown>;
     }
@@ -4050,6 +4295,64 @@ declare global {
         prototype: HTMLLimebbPropertySelectorElement;
         new (): HTMLLimebbPropertySelectorElement;
     };
+    interface HTMLLimebbRuleChipPopoverElementEventMap {
+        "negate": boolean;
+        "updateArgs": JsonValue;
+        "deleteChip": void;
+    }
+    /**
+     * Popover content for a rule-editor chip. Carries its own styles so
+     * they travel with the element when `limel-popover` portals it out of
+     * the rule-editor's shadow DOM.
+     * @private 
+     */
+    interface HTMLLimebbRuleChipPopoverElement extends Components.LimebbRuleChipPopover, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbRuleChipPopoverElementEventMap>(type: K, listener: (this: HTMLLimebbRuleChipPopoverElement, ev: LimebbRuleChipPopoverCustomEvent<HTMLLimebbRuleChipPopoverElementEventMap[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 HTMLLimebbRuleChipPopoverElementEventMap>(type: K, listener: (this: HTMLLimebbRuleChipPopoverElement, ev: LimebbRuleChipPopoverCustomEvent<HTMLLimebbRuleChipPopoverElementEventMap[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 HTMLLimebbRuleChipPopoverElement: {
+        prototype: HTMLLimebbRuleChipPopoverElement;
+        new (): HTMLLimebbRuleChipPopoverElement;
+    };
+    interface HTMLLimebbRuleEditorElementEventMap {
+        "change": Rule | undefined;
+    }
+    /**
+     * Tree editor for {@link Rule}.
+     * Renders a `Rule` value as a tree of nodes. Lets an author pick
+     * primitive refs in `all` / `any` groups, toggle negation, delete
+     * nodes, and edit per-primitive args via the editor declared on each
+     * primitive's metadata.
+     * The component is value-in / value-out. Pass `value` and listen for
+     * `change`; persistence is the caller's concern.
+     * Pass `availableSubjects` to forward the list of subject slots the
+     * caller knows will be available where the rule runs. The component
+     * forwards it to `RuleRegistry.validate` so `missing-slot` diagnostics
+     * surface inline on the offending nodes.
+     * @exampleComponent limebb-example-rule-editor
+     * @alpha 
+     * @private 
+     */
+    interface HTMLLimebbRuleEditorElement extends Components.LimebbRuleEditor, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLLimebbRuleEditorElementEventMap>(type: K, listener: (this: HTMLLimebbRuleEditorElement, ev: LimebbRuleEditorCustomEvent<HTMLLimebbRuleEditorElementEventMap[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 HTMLLimebbRuleEditorElementEventMap>(type: K, listener: (this: HTMLLimebbRuleEditorElement, ev: LimebbRuleEditorCustomEvent<HTMLLimebbRuleEditorElementEventMap[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 HTMLLimebbRuleEditorElement: {
+        prototype: HTMLLimebbRuleEditorElement;
+        new (): HTMLLimebbRuleEditorElement;
+    };
     /**
      * Renders its slot only when the configured rule evaluates true.
      * Pass a {@link Rule} and the gate compiles it on load and on prop
@@ -4057,6 +4360,7 @@ declare global {
      * {@link RuleRegistry} platform service.
      * @exampleComponent limebb-example-rule-gate
      * @alpha 
+     * @private 
      */
     interface HTMLLimebbRuleGateElement extends Components.LimebbRuleGate, HTMLStencilElement {
     }
@@ -4239,6 +4543,8 @@ declare global {
         "limebb-chat-icon-list": HTMLLimebbChatIconListElement;
         "limebb-chat-item": HTMLLimebbChatItemElement;
         "limebb-chat-list": HTMLLimebbChatListElement;
+        "limebb-color-palette-picker": HTMLLimebbColorPalettePickerElement;
+        "limebb-color-palette-swatches": HTMLLimebbColorPaletteSwatchesElement;
         "limebb-component-config": HTMLLimebbComponentConfigElement;
         "limebb-component-picker": HTMLLimebbComponentPickerElement;
         "limebb-composer-toolbar": HTMLLimebbComposerToolbarElement;
@@ -4290,6 +4596,8 @@ declare global {
         "limebb-object-chip": HTMLLimebbObjectChipElement;
         "limebb-percentage-visualizer": HTMLLimebbPercentageVisualizerElement;
         "limebb-property-selector": HTMLLimebbPropertySelectorElement;
+        "limebb-rule-chip-popover": HTMLLimebbRuleChipPopoverElement;
+        "limebb-rule-editor": HTMLLimebbRuleEditorElement;
         "limebb-rule-gate": HTMLLimebbRuleGateElement;
         "limebb-summary-popover": HTMLLimebbSummaryPopoverElement;
         "limebb-text-editor": HTMLLimebbTextEditorElement;
@@ -4496,6 +4804,92 @@ declare namespace LocalJSX {
          */
         "platform": LimeWebComponentPlatform;
     }
+    /**
+     * Picks a color palette from the built-in color-palettes registry,
+     * and shows the palette's swatches alongside its title — both in
+     * the dropdown row and in the selected trigger area.
+     * ### When to use this picker
+     * Use it when a Lime CRM widget needs the admin to choose a set of
+     * colors purely for **visual differentiation** between items in a
+     * list. The picker's contract is "give every item a distinct, nicely
+     * harmonized color"; it does **not** assume any item-to-color
+     * mapping is meaningful. Concrete examples:
+     * - bars / slices in a chart widget
+     * - swimlanes in a kanban view
+     * - event categories in a calendar
+     * - tag chips on a list view
+     * ### When **not** to use it
+     * Don't use this picker when colors carry semantic meaning that
+     * end users must learn and rely on — e.g. _red = high priority_,
+     * _green = healthy_, _yellow = pending_. The palette's color order
+     * and contents may evolve over time (designers tweaking shades,
+     * appending new colors, retiring duplicates), so item-to-color
+     * mappings are intentionally **not** stable across releases. For
+     * status / priority / severity surfaces, encode meaning at the
+     * value level (icons, badges, labels) rather than color alone.
+     * @exampleComponent limebb-example-color-palette-picker
+     * @beta 
+     */
+    interface LimebbColorPalettePicker {
+        /**
+          * Whether or not the current property is disabled
+          * @inheritdoc
+         */
+        "disabled"?: boolean;
+        /**
+          * The helper text for the current property
+          * @inheritdoc
+         */
+        "helperText"?: string;
+        /**
+          * @inheritdoc
+         */
+        "invalid"?: boolean;
+        /**
+          * The label of the current property
+          * @inheritdoc
+         */
+        "label"?: string;
+        /**
+          * Emitted when the user picks a different palette. The detail is the chosen palette's `id`.
+         */
+        "onChange"?: (event: LimebbColorPalettePickerCustomEvent<string>) => void;
+        /**
+          * 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;
+    }
+    /**
+     * Renders a small grid of color swatches for a palette. Used as the
+     * inline preview inside [limebb-color-palette-picker](..) — both in
+     * the trigger (the currently chosen palette) and in each row of its
+     * dropdown list (so users can see the colors before picking). Pass
+     * any CSS color strings (`rgb(var(--…))`, hex, etc.).
+     * The swatches are purely decorative — they carry no semantic
+     * information beyond what the surrounding context (e.g. the picker
+     * option's text and secondary text) already provides. The component
+     * marks itself `aria-hidden` so assistive tech skips it cleanly.
+     * @exampleComponent limebb-example-color-palette-swatches
+     * @private 
+     */
+    interface LimebbColorPaletteSwatches {
+        /**
+          * Ordered list of CSS color values to render as swatches.
+          * @default []
+         */
+        "colors"?: string[];
+    }
     /**
      * This component must be used in a limel-form
      * where the Command ID OR component name exists in the same section as the config.
@@ -6544,6 +6938,101 @@ declare namespace LocalJSX {
          */
         "value"?: string;
     }
+    /**
+     * Popover content for a rule-editor chip. Carries its own styles so
+     * they travel with the element when `limel-popover` portals it out of
+     * the rule-editor's shadow DOM.
+     * @private 
+     */
+    interface LimebbRuleChipPopover {
+        "context"?: LimeWebComponentContext;
+        /**
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * @default true
+         */
+        "isMutable"?: boolean;
+        /**
+          * @default false
+         */
+        "isNegated"?: boolean;
+        "metadata"?: PrimitiveMetadata;
+        "onDeleteChip"?: (event: LimebbRuleChipPopoverCustomEvent<void>) => void;
+        "onNegate"?: (event: LimebbRuleChipPopoverCustomEvent<boolean>) => void;
+        "onUpdateArgs"?: (event: LimebbRuleChipPopoverCustomEvent<JsonValue>) => void;
+        "platform"?: LimeWebComponentPlatform;
+        /**
+          * @default false
+         */
+        "readonly"?: boolean;
+        "refNode"?: RuleRef;
+    }
+    /**
+     * Tree editor for {@link Rule}.
+     * Renders a `Rule` value as a tree of nodes. Lets an author pick
+     * primitive refs in `all` / `any` groups, toggle negation, delete
+     * nodes, and edit per-primitive args via the editor declared on each
+     * primitive's metadata.
+     * The component is value-in / value-out. Pass `value` and listen for
+     * `change`; persistence is the caller's concern.
+     * Pass `availableSubjects` to forward the list of subject slots the
+     * caller knows will be available where the rule runs. The component
+     * forwards it to `RuleRegistry.validate` so `missing-slot` diagnostics
+     * surface inline on the offending nodes.
+     * @exampleComponent limebb-example-rule-editor
+     * @alpha 
+     * @private 
+     */
+    interface LimebbRuleEditor {
+        /**
+          * Subject slots the caller knows will be available where the rule runs. Forwarded to the rule registry's `validate` method so `missing-slot` issues surface inline. Leave unset when the evaluation context is not known (typical for editors that target the saved-rule library).
+         */
+        "availableSubjects"?: (keyof SubjectRegistry)[];
+        /**
+          * The context describing where this component is running.  The context provides information about the current limetype and record ID (if viewing/editing a specific record). Components can use this to load relevant data and understand their operating environment.
+         */
+        "context"?: LimeWebComponentContext;
+        /**
+          * Whether or not the current property is disabled The mutation UI is hidden when set. The args editor is rendered with `disabled` forwarded to it.
+          * @inheritdoc
+         */
+        "disabled"?: boolean;
+        /**
+          * The helper text for the current property
+          * @inheritdoc
+         */
+        "helperText"?: string;
+        /**
+          * The label of the current property
+          * @inheritdoc
+         */
+        "label"?: string;
+        /**
+          * Emitted when the rule tree is mutated. Detail is the new rule, or `undefined` when the user has cleared the editor to an empty root group — callers can persist `undefined` as "no rule" without having to inspect the rule shape themselves.
+         */
+        "onChange"?: (event: LimebbRuleEditorCustomEvent<Rule | undefined>) => void;
+        /**
+          * Reference to the platform service container.  Use this to access all platform services like repositories, HTTP client, command bus, navigator, and more. The platform instance is shared across all components in the same application context.
+         */
+        "platform"?: LimeWebComponentPlatform;
+        /**
+          * Whether or not the current property is readonly The mutation UI (delete and negate toggles, add-group button) is hidden when set. The args editor for each ref is still rendered, with `readonly` forwarded to it.
+          * @inheritdoc
+         */
+        "readonly"?: boolean;
+        /**
+          * Whether or not the current property is required
+          * @inheritdoc
+         */
+        "required"?: boolean;
+        /**
+          * The value of the current property
+          * @inheritdoc
+         */
+        "value"?: Rule | undefined;
+    }
     /**
      * Renders its slot only when the configured rule evaluates true.
      * Pass a {@link Rule} and the gate compiles it on load and on prop
@@ -6551,13 +7040,14 @@ declare namespace LocalJSX {
      * {@link RuleRegistry} platform service.
      * @exampleComponent limebb-example-rule-gate
      * @alpha 
+     * @private 
      */
     interface LimebbRuleGate {
         "platform"?: LimeWebComponentPlatform;
         /**
-          * The rule to evaluate.
+          * The rule to evaluate. When unset, the gate renders its slot unconditionally — "no rule" means "no gating", which mirrors the editor's `Rule | undefined` emit contract.
          */
-        "rule"?: Rule;
+        "rule"?: Rule | undefined;
         /**
           * Optional scope override. By default the gate resolves subject values by walking up the DOM to ancestors that registered providers with the rule registry. Pass an explicit scope to bypass that walk.
          */
@@ -6919,6 +7409,15 @@ declare namespace LocalJSX {
         "lastVisitedTimestamp": string | Date | null;
         "order": 'newest-on-top' | 'oldest-on-top';
     }
+    interface LimebbColorPalettePickerAttributes {
+        "value": string;
+        "required": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "disabled": boolean;
+        "label": string;
+        "helperText": string;
+    }
     interface LimebbComponentConfigAttributes {
         "required": boolean;
         "readonly": boolean;
@@ -7166,6 +7665,19 @@ declare namespace LocalJSX {
         "required": boolean;
         "helperText": string;
     }
+    interface LimebbRuleChipPopoverAttributes {
+        "isNegated": boolean;
+        "readonly": boolean;
+        "disabled": boolean;
+        "isMutable": boolean;
+    }
+    interface LimebbRuleEditorAttributes {
+        "required": boolean;
+        "readonly": boolean;
+        "disabled": boolean;
+        "label": string;
+        "helperText": string;
+    }
     interface LimebbSummaryPopoverAttributes {
         "triggerDelay": number;
         "heading": string;
@@ -7215,6 +7727,8 @@ declare namespace LocalJSX {
         "limebb-chat-icon-list": LimebbChatIconList;
         "limebb-chat-item": Omit<LimebbChatItem, keyof LimebbChatItemAttributes> & { [K in keyof LimebbChatItem & keyof LimebbChatItemAttributes]?: LimebbChatItem[K] } & { [K in keyof LimebbChatItem & keyof LimebbChatItemAttributes as `attr:${K}`]?: LimebbChatItemAttributes[K] } & { [K in keyof LimebbChatItem & keyof LimebbChatItemAttributes as `prop:${K}`]?: LimebbChatItem[K] };
         "limebb-chat-list": Omit<LimebbChatList, keyof LimebbChatListAttributes> & { [K in keyof LimebbChatList & keyof LimebbChatListAttributes]?: LimebbChatList[K] } & { [K in keyof LimebbChatList & keyof LimebbChatListAttributes as `attr:${K}`]?: LimebbChatListAttributes[K] } & { [K in keyof LimebbChatList & keyof LimebbChatListAttributes as `prop:${K}`]?: LimebbChatList[K] };
+        "limebb-color-palette-picker": Omit<LimebbColorPalettePicker, keyof LimebbColorPalettePickerAttributes> & { [K in keyof LimebbColorPalettePicker & keyof LimebbColorPalettePickerAttributes]?: LimebbColorPalettePicker[K] } & { [K in keyof LimebbColorPalettePicker & keyof LimebbColorPalettePickerAttributes as `attr:${K}`]?: LimebbColorPalettePickerAttributes[K] } & { [K in keyof LimebbColorPalettePicker & keyof LimebbColorPalettePickerAttributes as `prop:${K}`]?: LimebbColorPalettePicker[K] };
+        "limebb-color-palette-swatches": LimebbColorPaletteSwatches;
         "limebb-component-config": Omit<LimebbComponentConfig, keyof LimebbComponentConfigAttributes> & { [K in keyof LimebbComponentConfig & keyof LimebbComponentConfigAttributes]?: LimebbComponentConfig[K] } & { [K in keyof LimebbComponentConfig & keyof LimebbComponentConfigAttributes as `attr:${K}`]?: LimebbComponentConfigAttributes[K] } & { [K in keyof LimebbComponentConfig & keyof LimebbComponentConfigAttributes as `prop:${K}`]?: LimebbComponentConfig[K] };
         "limebb-component-picker": Omit<LimebbComponentPicker, keyof LimebbComponentPickerAttributes> & { [K in keyof LimebbComponentPicker & keyof LimebbComponentPickerAttributes]?: LimebbComponentPicker[K] } & { [K in keyof LimebbComponentPicker & keyof LimebbComponentPickerAttributes as `attr:${K}`]?: LimebbComponentPickerAttributes[K] } & { [K in keyof LimebbComponentPicker & keyof LimebbComponentPickerAttributes as `prop:${K}`]?: LimebbComponentPicker[K] };
         "limebb-composer-toolbar": Omit<LimebbComposerToolbar, keyof LimebbComposerToolbarAttributes> & { [K in keyof LimebbComposerToolbar & keyof LimebbComposerToolbarAttributes]?: LimebbComposerToolbar[K] } & { [K in keyof LimebbComposerToolbar & keyof LimebbComposerToolbarAttributes as `attr:${K}`]?: LimebbComposerToolbarAttributes[K] } & { [K in keyof LimebbComposerToolbar & keyof LimebbComposerToolbarAttributes as `prop:${K}`]?: LimebbComposerToolbar[K] };
@@ -7266,6 +7780,8 @@ declare namespace LocalJSX {
         "limebb-object-chip": Omit<LimebbObjectChip, keyof LimebbObjectChipAttributes> & { [K in keyof LimebbObjectChip & keyof LimebbObjectChipAttributes]?: LimebbObjectChip[K] } & { [K in keyof LimebbObjectChip & keyof LimebbObjectChipAttributes as `attr:${K}`]?: LimebbObjectChipAttributes[K] } & { [K in keyof LimebbObjectChip & keyof LimebbObjectChipAttributes as `prop:${K}`]?: LimebbObjectChip[K] };
         "limebb-percentage-visualizer": Omit<LimebbPercentageVisualizer, keyof LimebbPercentageVisualizerAttributes> & { [K in keyof LimebbPercentageVisualizer & keyof LimebbPercentageVisualizerAttributes]?: LimebbPercentageVisualizer[K] } & { [K in keyof LimebbPercentageVisualizer & keyof LimebbPercentageVisualizerAttributes as `attr:${K}`]?: LimebbPercentageVisualizerAttributes[K] } & { [K in keyof LimebbPercentageVisualizer & keyof LimebbPercentageVisualizerAttributes as `prop:${K}`]?: LimebbPercentageVisualizer[K] };
         "limebb-property-selector": Omit<LimebbPropertySelector, keyof LimebbPropertySelectorAttributes> & { [K in keyof LimebbPropertySelector & keyof LimebbPropertySelectorAttributes]?: LimebbPropertySelector[K] } & { [K in keyof LimebbPropertySelector & keyof LimebbPropertySelectorAttributes as `attr:${K}`]?: LimebbPropertySelectorAttributes[K] } & { [K in keyof LimebbPropertySelector & keyof LimebbPropertySelectorAttributes as `prop:${K}`]?: LimebbPropertySelector[K] };
+        "limebb-rule-chip-popover": Omit<LimebbRuleChipPopover, keyof LimebbRuleChipPopoverAttributes> & { [K in keyof LimebbRuleChipPopover & keyof LimebbRuleChipPopoverAttributes]?: LimebbRuleChipPopover[K] } & { [K in keyof LimebbRuleChipPopover & keyof LimebbRuleChipPopoverAttributes as `attr:${K}`]?: LimebbRuleChipPopoverAttributes[K] } & { [K in keyof LimebbRuleChipPopover & keyof LimebbRuleChipPopoverAttributes as `prop:${K}`]?: LimebbRuleChipPopover[K] };
+        "limebb-rule-editor": Omit<LimebbRuleEditor, keyof LimebbRuleEditorAttributes> & { [K in keyof LimebbRuleEditor & keyof LimebbRuleEditorAttributes]?: LimebbRuleEditor[K] } & { [K in keyof LimebbRuleEditor & keyof LimebbRuleEditorAttributes as `attr:${K}`]?: LimebbRuleEditorAttributes[K] } & { [K in keyof LimebbRuleEditor & keyof LimebbRuleEditorAttributes as `prop:${K}`]?: LimebbRuleEditor[K] };
         "limebb-rule-gate": LimebbRuleGate;
         "limebb-summary-popover": Omit<LimebbSummaryPopover, keyof LimebbSummaryPopoverAttributes> & { [K in keyof LimebbSummaryPopover & keyof LimebbSummaryPopoverAttributes]?: LimebbSummaryPopover[K] } & { [K in keyof LimebbSummaryPopover & keyof LimebbSummaryPopoverAttributes as `attr:${K}`]?: LimebbSummaryPopoverAttributes[K] } & { [K in keyof LimebbSummaryPopover & keyof LimebbSummaryPopoverAttributes as `prop:${K}`]?: LimebbSummaryPopover[K] };
         "limebb-text-editor": Omit<LimebbTextEditor, keyof LimebbTextEditorAttributes> & { [K in keyof LimebbTextEditor & keyof LimebbTextEditorAttributes]?: LimebbTextEditor[K] } & { [K in keyof LimebbTextEditor & keyof LimebbTextEditorAttributes as `attr:${K}`]?: LimebbTextEditorAttributes[K] } & { [K in keyof LimebbTextEditor & keyof LimebbTextEditorAttributes as `prop:${K}`]?: LimebbTextEditor[K] };
@@ -7362,6 +7878,47 @@ declare module "@stencil/core" {
              * @beta 
              */
             "limebb-chat-list": LocalJSX.IntrinsicElements["limebb-chat-list"] & JSXBase.HTMLAttributes<HTMLLimebbChatListElement>;
+            /**
+             * Picks a color palette from the built-in color-palettes registry,
+             * and shows the palette's swatches alongside its title — both in
+             * the dropdown row and in the selected trigger area.
+             * ### When to use this picker
+             * Use it when a Lime CRM widget needs the admin to choose a set of
+             * colors purely for **visual differentiation** between items in a
+             * list. The picker's contract is "give every item a distinct, nicely
+             * harmonized color"; it does **not** assume any item-to-color
+             * mapping is meaningful. Concrete examples:
+             * - bars / slices in a chart widget
+             * - swimlanes in a kanban view
+             * - event categories in a calendar
+             * - tag chips on a list view
+             * ### When **not** to use it
+             * Don't use this picker when colors carry semantic meaning that
+             * end users must learn and rely on — e.g. _red = high priority_,
+             * _green = healthy_, _yellow = pending_. The palette's color order
+             * and contents may evolve over time (designers tweaking shades,
+             * appending new colors, retiring duplicates), so item-to-color
+             * mappings are intentionally **not** stable across releases. For
+             * status / priority / severity surfaces, encode meaning at the
+             * value level (icons, badges, labels) rather than color alone.
+             * @exampleComponent limebb-example-color-palette-picker
+             * @beta 
+             */
+            "limebb-color-palette-picker": LocalJSX.IntrinsicElements["limebb-color-palette-picker"] & JSXBase.HTMLAttributes<HTMLLimebbColorPalettePickerElement>;
+            /**
+             * Renders a small grid of color swatches for a palette. Used as the
+             * inline preview inside [limebb-color-palette-picker](..) — both in
+             * the trigger (the currently chosen palette) and in each row of its
+             * dropdown list (so users can see the colors before picking). Pass
+             * any CSS color strings (`rgb(var(--…))`, hex, etc.).
+             * The swatches are purely decorative — they carry no semantic
+             * information beyond what the surrounding context (e.g. the picker
+             * option's text and secondary text) already provides. The component
+             * marks itself `aria-hidden` so assistive tech skips it cleanly.
+             * @exampleComponent limebb-example-color-palette-swatches
+             * @private 
+             */
+            "limebb-color-palette-swatches": LocalJSX.IntrinsicElements["limebb-color-palette-swatches"] & JSXBase.HTMLAttributes<HTMLLimebbColorPaletteSwatchesElement>;
             /**
              * This component must be used in a limel-form
              * where the Command ID OR component name exists in the same section as the config.
@@ -7975,6 +8532,30 @@ declare module "@stencil/core" {
              * @private 
              */
             "limebb-property-selector": LocalJSX.IntrinsicElements["limebb-property-selector"] & JSXBase.HTMLAttributes<HTMLLimebbPropertySelectorElement>;
+            /**
+             * Popover content for a rule-editor chip. Carries its own styles so
+             * they travel with the element when `limel-popover` portals it out of
+             * the rule-editor's shadow DOM.
+             * @private 
+             */
+            "limebb-rule-chip-popover": LocalJSX.IntrinsicElements["limebb-rule-chip-popover"] & JSXBase.HTMLAttributes<HTMLLimebbRuleChipPopoverElement>;
+            /**
+             * Tree editor for {@link Rule}.
+             * Renders a `Rule` value as a tree of nodes. Lets an author pick
+             * primitive refs in `all` / `any` groups, toggle negation, delete
+             * nodes, and edit per-primitive args via the editor declared on each
+             * primitive's metadata.
+             * The component is value-in / value-out. Pass `value` and listen for
+             * `change`; persistence is the caller's concern.
+             * Pass `availableSubjects` to forward the list of subject slots the
+             * caller knows will be available where the rule runs. The component
+             * forwards it to `RuleRegistry.validate` so `missing-slot` diagnostics
+             * surface inline on the offending nodes.
+             * @exampleComponent limebb-example-rule-editor
+             * @alpha 
+             * @private 
+             */
+            "limebb-rule-editor": LocalJSX.IntrinsicElements["limebb-rule-editor"] & JSXBase.HTMLAttributes<HTMLLimebbRuleEditorElement>;
             /**
              * Renders its slot only when the configured rule evaluates true.
              * Pass a {@link Rule} and the gate compiles it on load and on prop
@@ -7982,6 +8563,7 @@ declare module "@stencil/core" {
              * {@link RuleRegistry} platform service.
              * @exampleComponent limebb-example-rule-gate
              * @alpha 
+             * @private 
              */
             "limebb-rule-gate": LocalJSX.IntrinsicElements["limebb-rule-gate"] & JSXBase.HTMLAttributes<HTMLLimebbRuleGateElement>;
             /**