@limetech/lime-crm-building-blocks 2.0.4 → 2.2.0

package/dist/lime-crm-building-blocks/{p-ac97c7cc.entry.js → p-fc372344.entry.js}

@@ -1 +1 @@
-import{r as e,c as r,h as i}from"./p-COtSgrC5.js";const t=class{constructor(i){e(this,i),this.changeStartTime=r(this,"changeStartTime"),this.changeEndTime=r(this,"changeEndTime"),this.handleStartTimeChange=e=>{e.stopPropagation(),this.changeStartTime.emit(e.detail)},this.handleEndTimeChange=e=>{e.stopPropagation(),this.changeEndTime.emit(e.detail)}}componentWillLoad(){this.originalStartTime=this.startTime,this.originalEndTime=this.endTime}render(){return i("div",{key:"d413c4c15eb1e8108ac288f66ed00a4beb333b05",class:"date-pickers"},this.renderStartDatePicker(),this.renderEndDatePicker())}renderStartDatePicker(){if(this.originalStartTime)return i("div",{class:"start-time"},this.renderDatePicker(this.startTimeLabel,this.startTime,!this.startTime,this.handleStartTimeChange))}renderEndDatePicker(){if(this.originalEndTime)return i("div",{class:"end-time"},this.renderDatePicker(this.endTimeLabel,this.endTime,!this.endTime,this.handleEndTimeChange))}renderDatePicker(e,r,t,a){const l=this.platform&&i("limebb-date-picker",{platform:this.platform,context:this.context,type:this.type,value:r,onChange:a,invalid:t});return[i("div",{class:"label-group"},i("span",{class:"circle"}),i("span",{class:"label"},e),i("span",{class:"line"})),l||i("limel-date-picker",{type:this.type,value:r,format:this.timeFormat,language:this.language,onChange:a,invalid:t})]}};t.style=":host(limebb-date-range){isolation:isolate;display:block;position:relative}*{box-sizing:border-box}.date-pickers{display:grid;grid-template-columns:repeat(auto-fit, minmax(13.5rem, 1fr));gap:0.5rem;padding:0.75rem 1rem 1.25rem 1rem}.label-group{display:flex;align-items:center;margin-bottom:0.25rem}.end-time .label-group{flex-direction:row-reverse}.label-group .label{font-size:0.75rem;padding:0 0.25rem}.label-group .circle{flex-shrink:0;width:0.5rem;height:0.5rem;border-radius:50%}.start-time .label-group .circle{background-color:rgb(var(--color-green-default))}.end-time .label-group .circle{background-color:rgb(var(--color-coral-default))}.label-group .line{flex-grow:1;height:0.25rem;border-radius:1rem}.start-time .label-group .line{background-image:linear-gradient(to right, rgb(var(--color-green-light)), rgb(var(--contrast-400)) 30%)}.end-time .label-group .line{background-image:linear-gradient(to left, rgb(var(--color-coral-light)), rgb(var(--contrast-400)) 30%)}.date-pickers:has(>:last-child:nth-child(2)) .start-time .line{margin-right:-0.5rem}.date-pickers:has(>:last-child:nth-child(2)) .end-time .line{margin-left:-0.5rem}";export{t as limebb_date_range}
+import{r as e,c as r,h as i}from"./p-COtSgrC5.js";const t=class{constructor(i){e(this,i),this.changeStartTime=r(this,"changeStartTime"),this.changeEndTime=r(this,"changeEndTime"),this.handleStartTimeChange=e=>{e.stopPropagation(),this.changeStartTime.emit(e.detail)},this.handleEndTimeChange=e=>{e.stopPropagation(),this.changeEndTime.emit(e.detail)}}componentWillLoad(){this.originalStartTime=this.startTime,this.originalEndTime=this.endTime}render(){return i("div",{key:"164c0dd19a89356dcd9186768033d7974006dcb5",class:"date-pickers"},this.renderStartDatePicker(),this.renderEndDatePicker())}renderStartDatePicker(){if(this.originalStartTime)return i("div",{class:"start-time"},this.renderDatePicker(this.startTimeLabel,this.startTime,!this.startTime,this.handleStartTimeChange))}renderEndDatePicker(){if(this.originalEndTime)return i("div",{class:"end-time"},this.renderDatePicker(this.endTimeLabel,this.endTime,!this.endTime,this.handleEndTimeChange))}renderDatePicker(e,r,t,a){const l=this.platform&&i("limebb-date-picker",{platform:this.platform,context:this.context,type:this.type,value:r,onChange:a,invalid:t});return[i("div",{class:"label-group"},i("span",{class:"circle"}),i("span",{class:"label"},e),i("span",{class:"line"})),l||i("limel-date-picker",{type:this.type,value:r,format:this.timeFormat,language:this.language,onChange:a,invalid:t})]}};t.style=":host(limebb-date-range){isolation:isolate;display:block;position:relative}*{box-sizing:border-box}.date-pickers{display:grid;grid-template-columns:repeat(auto-fit, minmax(13.5rem, 1fr));gap:0.5rem;padding:0.75rem 1rem 1.25rem 1rem}.label-group{display:flex;align-items:center;margin-bottom:0.25rem}.end-time .label-group{flex-direction:row-reverse}.label-group .label{font-size:0.75rem;padding:0 0.25rem}.label-group .circle{flex-shrink:0;width:0.5rem;height:0.5rem;border-radius:50%}.start-time .label-group .circle{background-color:rgb(var(--color-green-default))}.end-time .label-group .circle{background-color:rgb(var(--color-coral-default))}.label-group .line{flex-grow:1;height:0.25rem;border-radius:1rem}.start-time .label-group .line{background-image:linear-gradient(to right, rgb(var(--color-green-light)), rgb(var(--contrast-400)) 30%)}.end-time .label-group .line{background-image:linear-gradient(to left, rgb(var(--color-coral-light)), rgb(var(--contrast-400)) 30%)}.date-pickers:has(>:last-child:nth-child(2)) .start-time .line{margin-right:-0.5rem}.date-pickers:has(>:last-child:nth-child(2)) .end-time .line{margin-left:-0.5rem}";export{t as limebb_date_range}

package/dist/types/components/condition-tree/condition-tree-combinators.d.ts

@@ -0,0 +1,47 @@
+import { ConditionTreeCombinator } from './condition-tree.types';
+/**
+ * Every combinator a group can use, in the order they are offered.
+ *
+ * @public
+ */
+export declare const CONDITION_TREE_COMBINATORS: readonly ConditionTreeCombinator[];
+/**
+ * The combinator to give a group nested inside one joined by `combinator`.
+ *
+ * The opposite join is the useful default: a group joined the same way as the
+ * one holding it says nothing the outer group does not already say. The
+ * negation is dropped with it, since a nested group has nothing to negate yet.
+ * @param combinator
+ */
+export declare function oppositeCombinator(combinator: ConditionTreeCombinator): ConditionTreeCombinator;
+interface CombinatorPresentation {
+    /**
+     * Color of the group's rail and of the separators between its rows. Kept as
+     * a literal CSS expression rather than a component-scoped custom property
+     * because it also has to reach the combinator dropdown, which renders
+     * through `limel-portal` and therefore outside this component's styles.
+     */
+    color: string;
+    iconName: string;
+    labelKey: string;
+    label: string;
+    descriptionKey: string;
+    description: string;
+    /**
+     * Whether the combinator is the negation of its conjunction, which decides
+     * both the marker prefix between rows and how a consumer unfolds it.
+     */
+    negated: boolean;
+    /**
+     * Which of the two shared delimiters marks the joins between rows.
+     */
+    delimiterKey: string;
+    delimiter: string;
+}
+/**
+ * How each combinator looks and reads. The labels are fallbacks used when the
+ * platform has no translation for the key next to them.
+ */
+export declare const COMBINATOR_PRESENTATION: Record<ConditionTreeCombinator, CombinatorPresentation>;
+export {};
+//# sourceMappingURL=condition-tree-combinators.d.ts.map

package/dist/types/components/condition-tree/condition-tree-editor/condition-tree-editor.d.ts

@@ -0,0 +1,84 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { ComponentDescriptor, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+/**
+ * The body of a condition's editor popover: the consumer's editor, and — for a
+ * condition that cannot express its own negation — a switch that negates it.
+ *
+ * It is an element of its own rather than markup inside the tree because
+ * `limel-popover` portals its content out of the tree's shadow DOM, leaving it
+ * behind. Carrying its own shadow root means its styles travel with it.
+ *
+ * @private
+ */
+export declare class ConditionTreeEditor {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Bridges the tree's context across the `limel-popover` portal.
+     */
+    context: LimeWebComponentContext;
+    /**
+     * Whether the popover holding this element is open.
+     *
+     * The element itself stays in place while closed, because `limel-popover`
+     * moves its content into the popover surface once and for all when that
+     * surface first loads — anything not there by then is never moved. Drawing
+     * nothing until asked is what keeps the consumer's editor from being built
+     * for every condition in the tree.
+     */
+    open: boolean;
+    /**
+     * The editor to mount, as given on the condition.
+     */
+    editor?: ComponentDescriptor;
+    /**
+     * The condition being edited, in the consumer's own model. Handed to the
+     * mounted editor as `value`.
+     */
+    value?: any;
+    /**
+     * Title of the condition, shown above the editor when there is a header to
+     * show at all.
+     */
+    heading?: string;
+    /**
+     * Whether the condition is negated. `undefined` means the condition
+     * expresses its own polarity and no switch is offered.
+     */
+    negated?: boolean;
+    /**
+     * @inheritdoc
+     */
+    readonly: boolean;
+    /**
+     * @inheritdoc
+     */
+    disabled: boolean;
+    /**
+     * Emitted when the user toggles the negation switch.
+     */
+    negateChange: EventEmitter<boolean>;
+    /**
+     * Emitted with the replacement condition when the mounted editor reports
+     * one.
+     *
+     * `limel-popover` portals this element out of the tree's shadow DOM, so an
+     * event from the editor never reaches the tree on its own. Catching it here
+     * and emitting it again is what carries it back across.
+     */
+    conditionChange: EventEmitter<any>;
+    render(): any[] | null;
+    /**
+     * The header exists only to hold the negation switch, so a condition that
+     * owns its polarity gets no header at all — its editor is the whole
+     * popover, exactly as if this element weren't here.
+     */
+    private renderHeader;
+    private renderBody;
+    private get negateLabel();
+    private handleNegate;
+    private handleConditionChange;
+}
+//# sourceMappingURL=condition-tree-editor.d.ts.map

package/dist/types/components/condition-tree/condition-tree-nodes.d.ts

@@ -0,0 +1,130 @@
+import { ConditionTreeAdapter, ConditionTreeCombinator, ConditionTreeDescription, ConditionTreeGroupDescription } from './condition-tree.types';
+/**
+ * The address of a node in the tree: the index of each step down from the root.
+ *
+ * The root itself is the empty path. `[1, 0]` is the first child of the second
+ * child of the root. Paths never leave the component — a consumer addresses its
+ * own tree by holding on to its own nodes — but the recursive render needs a
+ * way to say which node a control belongs to, and this is it.
+ */
+export type ConditionTreePath = number[];
+/**
+ * A stable string form of a path, for `key` attributes and for comparing two
+ * paths without an element-by-element loop at every call site.
+ * @param path
+ */
+export declare function pathKey(path: ConditionTreePath): string;
+/**
+ * Reads and rebuilds a consumer's tree through its adapter.
+ *
+ * Walking down goes through `describe`, so the tree never has to know how a
+ * consumer nests its nodes. Rebuilding goes up through `group`, and only groups
+ * are rebuilt: a condition is moved as the object it already is.
+ */
+export declare class ConditionTreeWalker<T> {
+    private adapter;
+    private isVisited;
+    /**
+     * @param adapter
+     * @param isVisited - Whether the user has opened and closed a node's
+     * editor. Read through a function rather than taken as a set, so that the
+     * walker outlives the tree's tally growing.
+     */
+    constructor(adapter: ConditionTreeAdapter<T>, isVisited?: (node: T) => boolean);
+    /**
+     * What the tree should draw for `node`.
+     * @param node
+     */
+    describe(node: T): ConditionTreeDescription<T>;
+    /**
+     * How `node` reads as a group, or `undefined` when it is a single
+     * condition rather than a group of them.
+     * @param node
+     */
+    groupOf(node: T): ConditionTreeGroupDescription<T> | undefined;
+    /**
+     * The children of a group, or `undefined` for a single condition.
+     * @param node
+     */
+    childrenOf(node: T): T[] | undefined;
+    /**
+     * The node at `path`, or `undefined` when the path leads nowhere — which
+     * happens routinely when the consumer replaces the tree while an editor is
+     * open.
+     * @param root
+     * @param path
+     */
+    nodeAt(root: T | undefined, path: ConditionTreePath): T | undefined;
+    /**
+     * The group at `path`, or `undefined` when the path leads nowhere or to a
+     * condition. Every caller that wants to look inside a group first has to
+     * find it and then find out whether it is one, so both steps live here.
+     * @param root
+     * @param path
+     */
+    groupAt(root: T | undefined, path: ConditionTreePath): ConditionTreeGroupDescription<T> | undefined;
+    /**
+     * Whether `node` is still somewhere in the tree, by identity.
+     *
+     * Identity rather than equality: a condition the tree did not touch is the
+     * very object the consumer handed over, so one that merely looks the same
+     * is a different condition.
+     * @param root
+     * @param node
+     */
+    contains(root: T | undefined, node: T): boolean;
+    /**
+     * Every condition asking to be opened, in display order.
+     *
+     * All of them rather than the first, because a consumer that leaves the
+     * flag on a condition it has already added would otherwise keep pointing at
+     * that one, and the next condition added would never get its turn.
+     * @param root
+     */
+    autoOpenNodes(root: T | undefined): T[];
+    /**
+     * The tree with the node at `path` replaced by `next`, or removed when
+     * `next` is `undefined`.
+     * @param root
+     * @param path
+     * @param next
+     */
+    replaceAt(root: T, path: ConditionTreePath, next: T | undefined): T | undefined;
+    /**
+     * The tree with `child` added to the end of the group at `path`. A path
+     * leading to a condition rather than a group leaves the tree alone: there
+     * is nothing there to add to.
+     * @param root
+     * @param path
+     * @param child
+     */
+    appendAt(root: T, path: ConditionTreePath, child: T): T | undefined;
+    /**
+     * The tree with the group at `path` joined by `combinator` instead, and
+     * what is inside it left alone. A path leading anywhere but a group leaves
+     * the tree as it was.
+     * @param root
+     * @param path
+     * @param combinator
+     */
+    rejoinAt(root: T, path: ConditionTreePath, combinator: ConditionTreeCombinator): T | undefined;
+    /**
+     * The tree with the condition at `path` negated, or not.
+     *
+     * An adapter with no way to rebuild a negated condition leaves the tree
+     * alone: it has already told the tree not to offer the control.
+     * @param root
+     * @param path
+     * @param negated
+     */
+    negateAt(root: T, path: ConditionTreePath, negated: boolean): T | undefined;
+    /**
+     * A group holding `children`, or nothing at all when there are none left: a
+     * group with nothing in it says nothing, so it goes the way of its last
+     * condition — and so, in turn, does the group that held it.
+     * @param combinator
+     * @param children
+     */
+    private rebuild;
+}
+//# sourceMappingURL=condition-tree-nodes.d.ts.map

package/dist/types/components/condition-tree/condition-tree-open-state.d.ts

@@ -0,0 +1,76 @@
+import { ConditionTreeWalker } from './condition-tree-nodes';
+/**
+ * Which condition's editor is open, and what the tree remembers about the user
+ * having been there.
+ *
+ * All of it is held by condition rather than by place in the tree, so that it
+ * survives the tree being rearranged around it.
+ *
+ * Every method returns a new state rather than changing this one, because
+ * `limebb-condition-tree` keeps it in `@State` and Stencil redraws on a new
+ * reference, not on a changed field.
+ */
+export declare class ConditionTreeOpenState {
+    private readonly fields;
+    private constructor();
+    static empty(): ConditionTreeOpenState;
+    get openNode(): unknown;
+    /**
+     * Whether the user has opened this condition's editor and closed it again.
+     * @param node
+     */
+    hasSeen(node: unknown): boolean;
+    /**
+     * The open editor moved onto `next`, or onto nothing at all, remembering
+     * the condition left behind — the moment the user is done with it for now,
+     * and the earliest anything can fairly judge it. Losing a condition because
+     * it went away is not the user leaving it: see `dropIfGone`.
+     * @param next
+     */
+    moveTo(next: unknown): ConditionTreeOpenState;
+    /**
+     * The same state, now waiting for `next` — the condition an editor just
+     * reported — to turn up in a tree from the consumer.
+     * @param next
+     */
+    expect(next: unknown): ConditionTreeOpenState;
+    /**
+     * The state brought up to date with a tree the consumer has just handed
+     * over: follow the condition that replaced the one being edited, open
+     * whatever is asking to be opened, and let go of a condition that is no
+     * longer there.
+     * @param root
+     * @param walker
+     */
+    sync(root: unknown, walker: ConditionTreeWalker<any>): ConditionTreeOpenState;
+    private with;
+    /**
+     * Move the editor onto the replacement, once the consumer has sent a tree
+     * holding it. One that reports the edit elsewhere, or normalizes the
+     * condition on the way through, never sends it back at all — the editor
+     * then stays where it is, and `dropIfGone` settles it if that has gone too.
+     * @param root
+     * @param walker
+     */
+    private followPending;
+    /**
+     * Open the condition that is asking for it and has not had its turn yet.
+     *
+     * A consumer is free to leave the flag on conditions it added earlier, so
+     * what settles this is not the flag alone but whether that condition has
+     * already been opened once. Conditions that stop asking are forgotten
+     * again, so one that is removed and put back opens anew.
+     * @param root
+     * @param walker
+     */
+    private openWhatAsks;
+    /**
+     * Let go of the open condition when it is no longer there — the user
+     * removed it, or the consumer replaced the tree under it. That is not the
+     * user finishing with it, so it does not count as having been seen.
+     * @param root
+     * @param walker
+     */
+    private dropIfGone;
+}
+//# sourceMappingURL=condition-tree-open-state.d.ts.map

package/dist/types/components/condition-tree/condition-tree-translate.d.ts

@@ -0,0 +1,11 @@
+import { LimeWebComponentPlatform } from '@limetech/lime-web-components';
+/**
+ * A translate function that falls back to the given English wording when the
+ * platform is absent or has no translation for the key.
+ *
+ * The tree is presentational and is rendered in docs and tests without a fully
+ * loaded platform, so it must read sensibly either way.
+ * @param platform
+ */
+export declare function createTranslator(platform?: LimeWebComponentPlatform): (key: string, fallback: string) => string;
+//# sourceMappingURL=condition-tree-translate.d.ts.map

package/dist/types/components/condition-tree/condition-tree-view-context.d.ts

@@ -0,0 +1,48 @@
+import { FunctionalComponent } from '../../stencil-public-runtime';
+import { ListSeparator, MenuItem } from '@limetech/lime-elements';
+import { LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { ConditionTreeCombinator } from './condition-tree.types';
+import { ConditionTreePath, ConditionTreeWalker } from './condition-tree-nodes';
+/**
+ * State and callbacks the tree passes down through its recursive render. Built
+ * once per render in `limebb-condition-tree`'s `render()`, and forwarded
+ * unchanged by every view.
+ *
+ * This module holds what both kinds of view need and imports neither of them,
+ * so that the recursion — a group drawing groups — runs one way down the import
+ * graph rather than back and forth across it.
+ */
+export interface ConditionTreeRenderContext {
+    platform: LimeWebComponentPlatform;
+    context: LimeWebComponentContext;
+    walker: ConditionTreeWalker<any>;
+    translate: (key: string, fallback: string) => string;
+    combinators: ConditionTreeCombinator[];
+    readonly: boolean;
+    disabled: boolean;
+    negatable: boolean;
+    openNode: unknown;
+    addOptions?: Array<MenuItem | ListSeparator>;
+    onAddLeaf: (path: ConditionTreePath, item?: MenuItem) => void;
+    onAddGroup: (path: ConditionTreePath) => void;
+    onDelete: (path: ConditionTreePath) => void;
+    onCombinator: (path: ConditionTreePath, combinator: ConditionTreeCombinator) => void;
+    onNegate: (path: ConditionTreePath, negated: boolean) => void;
+    onConditionChange: (path: ConditionTreePath, next: unknown) => void;
+    onOpen: (node: unknown) => void;
+}
+/**
+ * Problems reported on a node, listed beneath it.
+ * @param props
+ */
+export declare const IssuesView: FunctionalComponent<{
+    issues?: string[];
+}>;
+/**
+ * Throwing a node away. Shared because both kinds offer it: a group through
+ * the button in its header, a condition through the cross on its chip.
+ * @param path
+ * @param ctx
+ */
+export declare const handleDelete: (path: ConditionTreePath, ctx: ConditionTreeRenderContext) => (event: Event) => void;
+//# sourceMappingURL=condition-tree-view-context.d.ts.map

package/dist/types/components/condition-tree/condition-tree.d.ts

@@ -0,0 +1,177 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { ConditionTreeAdapter, ConditionTreeCombinator } from './condition-tree.types';
+import { ListSeparator, MenuItem } from '@limetech/lime-elements';
+/**
+ * The shared skeleton for editing a tree of conditions: nested groups joined by
+ * "All of the following" or "Any of the following", or the negations of those
+ * two, each holding conditions shown as chips, with the buttons that add,
+ * remove and regroup them.
+ *
+ * This component is deliberately ignorant of what a condition *is*.
+ *
+ * A condition is visualized as a chip, plus the tag name of an editor to open.
+ * So the same skeleton serves a condition that tests a property ("Deal value is
+ * greater than 100 000") and one that is opaque ("User is a member of a group")
+ * without either model leaking into it.
+ *
+ * It holds no tree of its own either. The consumer passes in its own tree, and
+ * an adapter that reads one node and rebuilds one group. Every structural edit
+ * — add, delete, regroup, rejoin, negate — is applied here and handed back as a
+ * tree of the same kind, so no consumer has to write that code twice.
+ *
+ * @exampleComponent limebb-example-condition-tree-basic
+ * @exampleComponent limebb-example-condition-tree-combinators
+ * @exampleComponent limebb-example-condition-tree-editors
+ * @exampleComponent limebb-example-condition-tree-palette
+ *
+ * @beta
+ */
+export declare class ConditionTree implements LimeWebComponent {
+    /**
+     * Platform service provider
+     */
+    platform: LimeWebComponentPlatform;
+    /**
+     * Component context, forwarded to each condition's editor.
+     */
+    context: LimeWebComponentContext;
+    /**
+     * The consumer's own tree, rendered as-is — the root node, in whatever
+     * shape `adapter` reads. Leave it unset for a tree with nothing in it yet,
+     * which draws an empty group asking for its first condition.
+     */
+    value?: any;
+    /**
+     * How to read and rebuild `value`. Build it once and hold on to it: one
+     * built inside a consumer's `render()` is a new object every time, which
+     * makes this component re-render for no reason.
+     *
+     * A Stencil element cannot be generic, so this is typed loosely here.
+     * Declare the adapter as `ConditionTreeAdapter<YourNode>` where you write
+     * it, and the compiler checks it against your own model.
+     */
+    adapter: ConditionTreeAdapter<any>;
+    /**
+     * Which combinators to offer in the group dropdowns, in the order given.
+     *
+     * All four are offered by default. "Not all of the following" and "None of
+     * the following" are harder to reason about than the two they negate, so a
+     * consumer whose users would be better served without them passes
+     * `['all', 'any']`. A group that already uses a combinator left off this
+     * list still shows it, rather than misrepresenting itself as using one of
+     * the offered ones.
+     */
+    combinators: ConditionTreeCombinator[];
+    /**
+     * The kinds of condition a user can add, offered as a menu when the add
+     * button is pressed. The chosen item is passed to `adapter.createLeaf`.
+     *
+     * Leave it unset when every condition in the tree is of the same kind:
+     * a blank one can simply be inserted, and its editor settles the rest, so
+     * pressing the button is the whole interaction. Set it when conditions come
+     * in kinds that have nothing in common — "the deal is worth more than
+     * 100 000", "the user belongs to a group", "it is the first day of the
+     * month" — where nothing can be inserted until the user says which.
+     *
+     * The menu has to be rendered here rather than by the consumer, because
+     * the button it hangs from lives inside this component.
+     */
+    addOptions?: Array<MenuItem | ListSeparator>;
+    /**
+     * Set to `true` when the tree is not the viewer's to change: the add,
+     * delete and negate controls are not rendered at all, leaving the
+     * conditions to be read. Use it where the tree is being shown rather than
+     * edited — a saved filter summarized on a card, or a rule the viewer has
+     * no rights over.
+     */
+    readonly: boolean;
+    /**
+     * Set to `true` when the tree *is* the viewer's to change, but not at this
+     * moment: every control stays where it is, dimmed and inert. Use it for a
+     * state that will pass — a form mid-save, or a tree behind an "Apply a
+     * filter" switch that is currently off.
+     */
+    disabled: boolean;
+    /**
+     * Emitted with the whole tree, of the consumer's own kind, whenever the
+     * user changes it. `null` means the last condition went and there is
+     * nothing left — an event carries no detail otherwise.
+     */
+    change: EventEmitter<any>;
+    /**
+     * Which editor is open, and what the user has already been through — see
+     * `condition-tree-open-state.ts`.
+     */
+    private openState;
+    private walker;
+    componentWillLoad(): void;
+    protected buildWalker(): void;
+    /**
+     * Nothing can be read out of a tree until there is an adapter to read it
+     * with, so a tree that arrives first waits here. `buildWalker` catches it
+     * up when the adapter turns up.
+     */
+    protected syncOpenState(): void;
+    render(): any;
+    /**
+     * The empty tree is drawn as the group it is about to become, rather than
+     * as a lone button: every condition here ends up inside a group, so the
+     * first one lands in a frame that was already on screen instead of
+     * conjuring one around itself. It can be filled either way round, with a
+     * condition or with a nested group.
+     */
+    private renderEmptyState;
+    private renderContext;
+    private addLeaf;
+    /**
+     * A nested group is joined the other way round from the one holding it: a
+     * group joined the same way as its parent would say nothing the parent does
+     * not already say.
+     * @param path
+     */
+    private addGroup;
+    /**
+     * What a new group starts with: one blank condition, so that a group is
+     * never handed over saying nothing — the same rule by which a group emptied
+     * of its last condition is dropped rather than kept. A consumer offering a
+     * menu of kinds is the exception, since the tree cannot know which kind to
+     * make.
+     */
+    private newGroupChildren;
+    /**
+     * Add a condition, or a group to put conditions in.
+     *
+     * Everything in this tree lives inside a group, so the first thing added
+     * to an empty one gets a root group to live in. After that the walker
+     * places it.
+     * @param path
+     * @param child
+     */
+    private grow;
+    /**
+     * An empty tree has nothing to edit.
+     * @param edit
+     */
+    private applyEdit;
+    /**
+     * Announce a tree the user has changed — unless it was not theirs to
+     * change. Every control is hidden or dimmed by then, so what this catches
+     * is an editor: the tree mounts whatever component a condition names, and
+     * has no way to make it honour the `readonly` it was handed.
+     * @param next
+     */
+    private emitChange;
+    /**
+     * Whether there is no tree yet — which is not the same as a tree that
+     * happens to be an empty group.
+     */
+    private get isEmpty();
+    /**
+     * The combinator a group made here is joined by: the first one the consumer
+     * offers, so a tree that never offers "All of the following" never invents
+     * one.
+     */
+    private rootCombinator;
+}
+//# sourceMappingURL=condition-tree.d.ts.map