@orangelogic/design-system 2.150.0 → 2.151.0

package/library/components/video.js

@@ -1,14 +1,14 @@
 import { _ as kd, a as Sa, b as Be, c as Je } from "../chunks/inheritsLoose.BuSn_CvZ.js";
 import { c as ps, a as Bn } from "../chunks/_commonjsHelpers.DQNKXVTB.js";
 import { r as Sb } from "../chunks/___vite-browser-external_commonjs-proxy.C2tf3HsQ.js";
-import { C as Cb } from "../chunks/image.C-rHqDVB.js";
+import { C as Cb } from "../chunks/image.DYRVQgG1.js";
 import Mb from "./resize-observer.js";
 import { r as Db, R as Pb, a as Rp, b as Lb } from "../chunks/resizable-component.styles.CAfXABBc.js";
 import { c as Rb } from "../chunks/component.styles.CRO4Odto.js";
 import { b as Ib } from "../chunks/browser.BHOCIF_A.js";
 import { c as Ob } from "../chunks/custom-element.L4WJXn1j.js";
-import { L as kb } from "../chunks/i18n.BwXikn4k.js";
-import { w as Ki } from "../chunks/watch.K-dbDP6P.js";
+import { L as kb } from "../chunks/i18n.Bchq8v1d.js";
+import { w as Ki } from "../chunks/watch.DOt4Mabe.js";
 import { i as Bb, x as Qc } from "../chunks/lit-element.jLBm65_O.js";
 import { n as Ri } from "../chunks/lib-cortex-element.CVMmyPMC.js";
 import { r as yn } from "../chunks/state.CSDxrqLd.js";

package/library/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orangelogic/design-system",
   "type": "module",
-  "version": "2.150.0",
+  "version": "2.151.0",
   "license": "UNLICENSED",
   "types": "library/types.d.ts",
   "scripts": {

package/library/packages/events/src/cx-xml-editor-asset-type-change.d.ts

@@ -0,0 +1,8 @@
+export type CxXmlEditorAssetTypeChangeEvent = CustomEvent<{
+    value: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-xml-editor-asset-type-change': CxXmlEditorAssetTypeChangeEvent;
+    }
+}

package/library/packages/events/src/cx-xml-editor-change.d.ts

@@ -0,0 +1,8 @@
+export type CxXmlEditorChangeEvent = CustomEvent<{
+    value: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-xml-editor-change': CxXmlEditorChangeEvent;
+    }
+}

package/library/packages/events/src/cx-xml-editor-element-action.d.ts

@@ -0,0 +1,11 @@
+import { XmlEditorElementActionKind, XmlEditorTag } from '../../types/src/xml-editor';
+
+export type CxXmlEditorElementActionEvent = CustomEvent<{
+    action: XmlEditorElementActionKind;
+    name: XmlEditorTag;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-xml-editor-element-action': CxXmlEditorElementActionEvent;
+    }
+}

package/library/packages/events/src/cx-xml-editor-element-expand-toggle.d.ts

@@ -0,0 +1,8 @@
+export type CxXmlEditorElementExpandToggleEvent = CustomEvent<{
+    expand: boolean;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-xml-editor-element-expand-toggle': CxXmlEditorElementExpandToggleEvent;
+    }
+}

package/library/packages/events/src/cx-xml-editor-notify.d.ts

@@ -0,0 +1,11 @@
+import { XmlEditorNotifyType } from '../../types/src/xml-editor';
+
+export type CxXmlEditorNotifyEvent = CustomEvent<{
+    message: string;
+    type: XmlEditorNotifyType;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-xml-editor-notify': CxXmlEditorNotifyEvent;
+    }
+}

package/library/packages/events/src/cx-xml-editor-packet-change.d.ts

@@ -0,0 +1,11 @@
+import { XmlEditorPacketActionType, XmlEditorPacketPayload } from '../../types/src/xml-editor';
+
+export type CxXmlEditorPacketChangeEvent = CustomEvent<{
+    payload: XmlEditorPacketPayload;
+    type: XmlEditorPacketActionType;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-xml-editor-packet-change': CxXmlEditorPacketChangeEvent;
+    }
+}

package/library/packages/events/src/events.d.ts

@@ -232,3 +232,9 @@ export * from './cx-video-editor-track-click';
 export * from './cx-video-editor-transition-click';
 export * from './cx-video-thumbnail-resolved';
 export * from './cx-view-logs';
+export * from './cx-xml-editor-asset-type-change';
+export * from './cx-xml-editor-change';
+export * from './cx-xml-editor-element-action';
+export * from './cx-xml-editor-element-expand-toggle';
+export * from './cx-xml-editor-notify';
+export * from './cx-xml-editor-packet-change';

package/library/packages/hybrid/table-core/src/table/table-data-loader.d.ts

@@ -2,8 +2,8 @@ import { ColumnDefinition, TableDataFormat } from '../../../../types/src/table';
 
 export type StreamChunkCallback = (rows: Array<Record<string, unknown>>) => Promise<void>;
 export declare function parseCsvStream(raw: string, onColumns: (columns: ColumnDefinition[]) => void, onChunk: StreamChunkCallback, chunkSize?: number): Promise<number>;
-export declare function parseXmlStream(raw: string, onColumns: (columns: ColumnDefinition[]) => void, onChunk: StreamChunkCallback, chunkSize?: number): Promise<number>;
-export declare function parseJsonStream(raw: string, onColumns: (columns: ColumnDefinition[]) => void, onChunk: StreamChunkCallback, chunkSize?: number): Promise<number>;
+export declare function parseXmlStream(raw: string, onColumns: (columns: ColumnDefinition[]) => void, onChunk: StreamChunkCallback, chunkSize?: number, urlPath?: string): Promise<number>;
+export declare function parseJsonStream(raw: string, onColumns: (columns: ColumnDefinition[]) => void, onChunk: StreamChunkCallback, chunkSize?: number, urlPath?: string): Promise<number>;
 export interface ParsedTableData {
     columns: ColumnDefinition[];
     data: Array<Record<string, unknown>>;

package/library/packages/hybrid/table-core/src/table/table.d.ts

@@ -801,6 +801,14 @@ export default class CxTable extends CortexElement {
     dateFilterCompareFormat: DateFilterCompareFormat;
     /** Format of the data at dataUrl. Use 'auto' to detect from URL extension or Content-Type header. */
     dataFormat: TableDataFormat;
+    /**
+     * Dot- or slash-notation path (e.g. `data.items` or `result/rows/0/list`) to the row data within
+     * a `dataUrl` response, for payloads that don't already match the default shape:
+     * - `json`: not already a bare array or a `{ columns, data }` envelope.
+     * - `xml`: not already a bare element list or a `{ columns, rows }` envelope.
+     * Has no effect on `csv` data.
+     */
+    dataUrlPath: string;
     /**
      * When true, a `dataUrl` load keeps existing `columns` as-is instead of auto-populating them
      * from the loaded file's headers. Has no effect when `columns` is empty — auto-detection still

package/library/packages/molecules/src/annotator/annotator.d.ts

@@ -73,6 +73,18 @@ export default class CxAnnotator extends CortexElement {
     private handleMarkerCreate;
     private handleMarkerChange;
     private handleMarkerDelete;
+    /**
+     * Re-arms the armed drawing tool when the pointer re-enters the marker area.
+     *
+     * MarkerJS 3 requires an explicit `createMarker()` call to (re)enter drawing
+     * mode. When the pointer leaves the marker area (e.g. the user clicks the
+     * video controls to play/pause) and comes back while a tool is still armed,
+     * the previously armed "new" marker no longer reacts to the first click,
+     * forcing an extra activating click. Re-creating the marker of the current
+     * type on re-entry restores the "sticky tool" feel of the legacy MarkerJS 2
+     * UI so the next click draws immediately.
+     */
+    private handlePointerEnter;
     private handleKeydown;
     private handleToolClick;
     private handleAddArrowClick;

package/library/packages/molecules/src/dynamic-select/dynamic-select.d.ts

@@ -136,6 +136,15 @@ export default class CxDynamicSelect extends CortexElement {
      * @returns The value
      */
     getOptionValue: (option: HTMLElement) => string;
+    /**
+     * Optional override for the label shown in the closed select's display text (and used for text-based matching)
+     * when `columns` (table mode) is set. Table mode otherwise derives the label from the first rendered `<td>`;
+     * provide this to use a different column, or to combine several columns into one summary (e.g. "A -> B").
+     *
+     * @param option The option to get the label for
+     * @returns The label
+     */
+    getOptionLabel?: (option: HTMLElement) => string;
     /**
      *
      * current = whether the option is currently focused on e.g via keyboard

package/library/packages/organisms/src/index.d.ts

@@ -24,3 +24,4 @@ export { default as CxTemplateSwitcher } from './template-switcher/template-swit
 export { default as CxTextToSpeech } from './text-to-speech/text-to-speech';
 export { default as CxVideoChaptersManager } from './video-chapters-manager/video-chapters-manager';
 export { default as CxVideoEditor } from './video-editor/video-editor';
+export { default as CxXmlEditor } from './xml-editor/xml-editor';

package/library/packages/organisms/src/xml-editor/components/asset-type/asset-type.d.ts

@@ -0,0 +1,38 @@
+import { default as CxOption } from '../../../../../atoms/src/components/option/option.ts';
+import { default as CxSelect } from '../../../../../atoms/src/components/select/select.ts';
+import { default as CortexElement } from '../../../../../base/src/cortex-element.ts';
+import { CSSResultGroup } from 'lit';
+
+/**
+ * @summary Two cascading selects (Type -> Subtype) that together produce a single fully-qualified
+ * `DO_DOCUMENTS.<typeDbBOName>.<subTypeValue>` asset-type path, used by `packet-editor`'s TypeFilters rows.
+ *
+ * @event cx-xml-editor-asset-type-change - Emitted with the fully-qualified asset-type path once both selections resolve.
+ */
+export default class CxXmlEditorAssetType extends CortexElement {
+    #private;
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-option': typeof CxOption;
+        'cx-select': typeof CxSelect;
+    };
+    private readonly localize;
+    /** The fully-qualified asset-type path currently selected (e.g. `DO_DOCUMENTS.Image_DbBO.Image_Default`). */
+    value: string;
+    /** Subtypes grouped by type label, then by subtype label, as produced by `apiGetSubTypesWithWildcard`. */
+    subTypesMap: Record<string, Record<string, {
+        subTypeValue: string;
+        typeDbBOName: string;
+    }>>;
+    /** The currently selected type label (first select's value). */
+    private typeValue;
+    /** The currently selected subtype label (second select's value). */
+    private subTypeValue;
+    handleValueChange(): void;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-xml-editor-asset-type': CxXmlEditorAssetType;
+    }
+}

package/library/packages/organisms/src/xml-editor/components/asset-type/asset-type.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/organisms/src/xml-editor/components/element-tag/element-tag.d.ts

@@ -0,0 +1,66 @@
+import { default as CxButton } from '../../../../../atoms/src/components/button/button.ts';
+import { default as CxIcon } from '../../../../../atoms/src/components/icon/icon.ts';
+import { default as CxIconButton } from '../../../../../atoms/src/components/icon-button/icon-button.ts';
+import { default as CxTooltip } from '../../../../../atoms/src/components/tooltip/tooltip.ts';
+import { default as CxTypography } from '../../../../../atoms/src/components/typography/typography.ts';
+import { default as CortexElement } from '../../../../../base/src/cortex-element.ts';
+import { XmlEditorElement, XmlEditorTag } from '../../../../../types/src/xml-editor';
+import { CSSResultGroup } from 'lit';
+
+/**
+ * @summary One row of the Fetch Rules tree: the tag's title/order, expand/collapse control, a hover action menu
+ * (edit attributes / add / copy / paste / delete), and — for `Packet` — the slotted `packet-editor`. Children render
+ * through the default slot as nested `cx-xml-editor-element-tag` instances.
+ *
+ * @slot (default) - Nested `cx-xml-editor-element-tag` rows for this element's children.
+ * @slot packet-editor - The `cx-xml-editor-packet-editor` shown in place while a `Packet` row is expanded.
+ *
+ * @event cx-xml-editor-element-action - Emitted (not composed) when a hover-menu action is triggered.
+ * @event cx-xml-editor-element-expand-toggle - Emitted (not composed) when the expand/collapse control is toggled.
+ */
+export default class CxXmlEditorElementTag extends CortexElement {
+    #private;
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-button': typeof CxButton;
+        'cx-icon': typeof CxIcon;
+        'cx-icon-button': typeof CxIconButton;
+        'cx-tooltip': typeof CxTooltip;
+        'cx-typography': typeof CxTypography;
+    };
+    /** The direct child tag name for a given parent tag (e.g. `FetchRules` -> `Generation`). */
+    private static getDirectChildName;
+    private readonly localize;
+    /** The tree node this row renders. */
+    self: XmlEditorElement;
+    /**
+     * The parent element that owns this row. Threaded through as a plain property (rather than closed over per-row)
+     * so the host can read `event.target.self` / `.parent` from a single bound listener instead of allocating a new
+     * per-node arrow function on every render (which `lit/no-template-arrow` disallows).
+     */
+    parent?: XmlEditorElement;
+    /** The tag name for this row. */
+    name: XmlEditorTag;
+    /** Whether this row is currently expanded. */
+    expanded: boolean;
+    /** 1-based order label shown next to the tag name (e.g. `1` or `1.2`). */
+    order: string;
+    /** Whether this row is the tree's root (suppresses copy/delete/paste and draws no border). */
+    isRoot: boolean;
+    canAdd: boolean;
+    canEdit: boolean;
+    canCopy: boolean;
+    canPaste: boolean;
+    canDelete: boolean;
+    /** Hover-driven visibility of the action menu, independent of the always-visible Packet editing state. */
+    private showMenu;
+    handleNameChange(): void;
+    handleIsRootChange(): void;
+    private handleActionButtonClick;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-xml-editor-element-tag': CxXmlEditorElementTag;
+    }
+}

package/library/packages/organisms/src/xml-editor/components/element-tag/element-tag.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/organisms/src/xml-editor/components/packet-editor/packet-editor.d.ts

@@ -0,0 +1,78 @@
+import { default as CxButton } from '../../../../../atoms/src/components/button/button.ts';
+import { default as CxCheckbox } from '../../../../../atoms/src/components/checkbox/checkbox.ts';
+import { default as CxDivider } from '../../../../../atoms/src/components/divider/divider.ts';
+import { default as CxGrid } from '../../../../../atoms/src/components/grid/grid.ts';
+import { default as CxGridItem } from '../../../../../atoms/src/components/grid-item/grid-item.ts';
+import { default as CxIcon } from '../../../../../atoms/src/components/icon/icon.ts';
+import { default as CxIconButton } from '../../../../../atoms/src/components/icon-button/icon-button.ts';
+import { default as CxInput } from '../../../../../atoms/src/components/input/input.ts';
+import { default as CxTooltip } from '../../../../../atoms/src/components/tooltip/tooltip.ts';
+import { default as CxTypography } from '../../../../../atoms/src/components/typography/typography.ts';
+import { default as CortexElement } from '../../../../../base/src/cortex-element.ts';
+import { default as CxDynamicSelect } from '../../../../../molecules/src/dynamic-select/dynamic-select.ts';
+import { XmlEditorElement, XmlEditorRelationData, XmlEditorSameFieldData, XmlEditorSortOrderData, XmlEditorSubTypeData } from '../../../../../types/src/xml-editor';
+import { CSSResultGroup } from 'lit';
+import { default as CxXmlEditorAssetType } from '../asset-type/asset-type';
+
+/**
+ * @summary The Packet node editor: explore rules (ancestors/descendants/self/relations/same-field/similarity),
+ * asset-type filters, additional Search API filters, and order-by/limit — the in-place expanded editor for the
+ * `Packet` tag rendered by `element-tag`.
+ *
+ * @event cx-xml-editor-packet-change - Emitted with the ported `PacketAction`/`XmlEditorPacketPayload` protocol for every mutation.
+ */
+export default class CxXmlEditorPacketEditor extends CortexElement {
+    #private;
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-button': typeof CxButton;
+        'cx-checkbox': typeof CxCheckbox;
+        'cx-divider': typeof CxDivider;
+        'cx-dynamic-select': typeof CxDynamicSelect;
+        'cx-grid': typeof CxGrid;
+        'cx-grid-item': typeof CxGridItem;
+        'cx-icon': typeof CxIcon;
+        'cx-icon-button': typeof CxIconButton;
+        'cx-input': typeof CxInput;
+        'cx-tooltip': typeof CxTooltip;
+        'cx-typography': typeof CxTypography;
+        'cx-xml-editor-asset-type': typeof CxXmlEditorAssetType;
+    };
+    /**
+     * Maps enabled relations into `cx-dynamic-select` options + table columns (replaces React `Relation.tsx`).
+     * Column headers are supplied by the caller (which owns a `LocalizeController`) rather than hardcoded here.
+     */
+    private static mapRelationsToOptions;
+    /** Maps sort orders into `cx-dynamic-select` options + table columns (replaces React `OrderBy.tsx`). */
+    private static mapSortOrdersToOptions;
+    /** Maps same-field candidates into `cx-dynamic-select` options + table columns (replaces React `SameField.tsx`). */
+    private static mapSameFieldsToOptions;
+    private readonly localize;
+    /** The `Packet` element being edited. */
+    value: XmlEditorElement;
+    enabledRelations: XmlEditorRelationData[];
+    subTypes: XmlEditorSubTypeData[];
+    subTypesMap: Record<string, Record<string, {
+        subTypeValue: string;
+        typeDbBOName: string;
+    }>>;
+    sortOrders: XmlEditorSortOrderData[];
+    sameFields: XmlEditorSameFieldData[];
+    /** Whether the "Assets that share the same value on field" row is expanded even without a stored value yet. */
+    private enabledSameField;
+    private updateExtraFiltersDebounced;
+    private updateLimitDebounced;
+    /**
+     * `cx-dynamic-select`'s `getOptionLabel` override for the Relation picker — matches the tooltip and the original
+     * React `Relation.tsx` (which set the same override directly on its `cx-select` ref): "parentRole -> childRole"
+     * read from the 3rd/4th `<td>`, per `mapRelationsToOptions`'s column order, instead of the table mode default of
+     * just the first column's text.
+     */
+    private getRelationOptionLabel;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-xml-editor-packet-editor': CxXmlEditorPacketEditor;
+    }
+}

package/library/packages/organisms/src/xml-editor/components/packet-editor/packet-editor.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/organisms/src/xml-editor/components/viewer/viewer.d.ts

@@ -0,0 +1,37 @@
+import { default as CxIconButton } from '../../../../../atoms/src/components/icon-button/icon-button.ts';
+import { default as CxTooltip } from '../../../../../atoms/src/components/tooltip/tooltip.ts';
+import { default as CxTypography } from '../../../../../atoms/src/components/typography/typography.ts';
+import { default as CortexElement } from '../../../../../base/src/cortex-element.ts';
+import { XmlEditorTreeNode } from '../../../../../types/src/xml-editor';
+import { CSSResultGroup } from 'lit';
+
+/**
+ * @summary Read-only debug preview of the current Fetch Rules tree as raw XML, with a pretty-print / minify toggle.
+ */
+export default class CxXmlEditorViewer extends CortexElement {
+    #private;
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-icon-button': typeof CxIconButton;
+        'cx-tooltip': typeof CxTooltip;
+        'cx-typography': typeof CxTypography;
+    };
+    /** Serializes a `XmlEditorTreeNode` to a single-line (minified) XML string, the sibling of `convertToIndentXMLForDownload`. */
+    private static convertToXMLForDownload;
+    /**
+     * Serializes a `XmlEditorTreeNode` back to a pretty-printed XML string. Also called by `cx-xml-editor` (persisted
+     * `value` / clipboard copy), which is why this stays `static` rather than an instance-only method.
+     */
+    static convertToIndentXMLForDownload(data: XmlEditorTreeNode, xml: string[], indent: string): string[];
+    private readonly localize;
+    /** The Fetch Rules tree to preview. */
+    xml: XmlEditorTreeNode;
+    /** Whether the preview is pretty-printed (indented) rather than minified. */
+    private indented;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-xml-editor-viewer': CxXmlEditorViewer;
+    }
+}

package/library/packages/organisms/src/xml-editor/components/viewer/viewer.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/organisms/src/xml-editor/xml-editor.d.ts

@@ -0,0 +1,75 @@
+import { default as CortexElement } from '../../../base/src/cortex-element.ts';
+import { XmlEditorElement, XmlEditorNodeType, XmlEditorTreeNode } from '../../../types/src/xml-editor';
+import { CSSResultGroup, TemplateResult } from 'lit';
+import { default as CxXmlEditorElementTag } from './components/element-tag/element-tag';
+import { default as CxXmlEditorPacketEditor } from './components/packet-editor/packet-editor';
+import { default as CxXmlEditorViewer } from './components/viewer/viewer';
+
+/**
+ * @summary Structured tree editor for the `<FetchRules>` XML rule schema: expand/collapse, add/copy/paste/delete
+ * elements, edit `Packet` search rules, and preview the resulting XML. Replaces the legacy React `orangelogic-react-xmleditor`
+ * component; the host page owns persistence and listens for `cx-xml-editor-change`.
+ *
+ * @event cx-xml-editor-change - Emitted with the serialized XML string after every tree mutation.
+ * @event cx-xml-editor-notify - Emitted with a short user-facing message (e.g. after copying a node to the clipboard).
+ */
+export default class CxXmlEditor extends CortexElement {
+    #private;
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-xml-editor-element-tag': typeof CxXmlEditorElementTag;
+        'cx-xml-editor-packet-editor': typeof CxXmlEditorPacketEditor;
+        'cx-xml-editor-viewer': typeof CxXmlEditorViewer;
+    };
+    /** Tags whose direct text content becomes a `Text`-node child, mirroring the ported schema's `TEXT_TAGS` set. */
+    private static readonly TEXT_TAGS;
+    static findElementIndex(parent: XmlEditorElement, key: string, value: XmlEditorElement): number;
+    static getNewElement(key: string, type: XmlEditorNodeType, attributes?: {
+        [id: string]: string;
+    }): XmlEditorElement;
+    static deleteElement(parent: XmlEditorElement, key: string, value: XmlEditorElement): XmlEditorTreeNode | null;
+    /** Parses a Fetch Rules XML string into a `XmlEditorTreeNode`, or `null` if `xmlString` is empty or malformed. */
+    static loadXML(xmlString: string): XmlEditorTreeNode | null;
+    private static isTextTag;
+    private static getDirectParentName;
+    private static traverseXMLElements;
+    private static appendTextNode;
+    private static appendElementNode;
+    private static removeEmptyElements;
+    private apiGetAllAliasFields;
+    private apiGetAllSearchableFieldsForCurrentUser;
+    private apiGetEnabledRelations;
+    private apiGetSortOrders;
+    private apiGetSubTypesWithWildcard;
+    /** The initial Fetch Rules XML. Subsequent edits are reported via `cx-xml-editor-change`, not by re-setting this. */
+    value: string;
+    /** Shows the raw-XML debug preview below the tree when true. */
+    debug: boolean;
+    /** The parsed Fetch Rules tree currently rendered. `null` until the initial XML has been parsed. */
+    private tree;
+    /** The node most recently copied via the tree's hover menu, available for a single paste. */
+    private copiedNode;
+    private referenceDataLoading;
+    private enabledRelations;
+    private sortOrders;
+    private subTypes;
+    private subTypesMap;
+    private metadataFields;
+    private sameFields;
+    connectedCallback(): void;
+    /**
+     * Parses `value` into `tree` — both for the initial render and whenever a host reassigns `value` after connection
+     * (e.g. once async data finishes loading). Deliberately not `waitUntilFirstUpdate`: a host that sets `value`
+     * synchronously right after creating the element (still before this element's first Lit update flushes) needs
+     * that assignment picked up on the first update too, not skipped as though it were the property's own default.
+     */
+    handleValueChange(): void;
+    private updateTree;
+    private refreshTree;
+    render(): TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-xml-editor': CxXmlEditor;
+    }
+}

package/library/packages/organisms/src/xml-editor/xml-editor.data.d.ts

@@ -0,0 +1,23 @@
+import { XmlEditorElement, XmlEditorElementActionKind, XmlEditorTag } from '../../../types/src/xml-editor';
+
+export declare const Default: {
+    ElementName: string;
+    Tab: string;
+    TextName: string;
+    XML: Record<string, XmlEditorElement>;
+};
+export declare const DefaultXMLString = "\n<FetchRules>\n  <Generation>\n    <Packet>\n      <Relations>\n      </Relations>\n    </Packet>\n  </Generation>\n</FetchRules>\n";
+export declare const TagMap: {
+    [id in XmlEditorTag]?: {
+        attributes?: string[];
+        children?: XmlEditorTag[];
+    };
+};
+export declare const AttributeDefaultValue: {
+    [key: string]: string[];
+};
+export declare const TagActionMap: {
+    [id in XmlEditorTag]?: {
+        [action in XmlEditorElementActionKind]?: true;
+    };
+};

package/library/packages/organisms/src/xml-editor/xml-editor.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/services/src/api/endpoints.d.ts

@@ -25,6 +25,9 @@ export declare enum DASHBOARD_API_ENDPOINT {
     GET_DASHBOARD_LIST = "webapi/extensibility/integrations/businessintelligence/getlistdashboards_41JI_v1"
 }
 export declare enum METADATA_API_ENDPOINT {
+    GET_ALL_ALIAS_FIELDS = "webapi/objectmanagement/metadata/fields/getallaliasfields_4C3_v1",
+    GET_ALL_SEARCHABLE_FIELDS_FOR_CURRENT_USER = "webapi/objectmanagement/metadata/fields/getallsearchablefieldsforcurrentuser_241_v1",
+    GET_ENABLED_RELATIONS = "webapi/objectmanagement/relations/getenabledrelations_49S_v1",
     GET_SEARCHABLE_FIELDS = "webapi/objectmanagement/metadata/fields/getallobjectfieldsforcurrentuser_4C2_v2",
     GET_SORT_ORDERS = "webapi/objectmanagement/sortorders_49V_v1",
     GET_SUBTYPES_WITH_WILDCARD = "webapi/document/doctype/subtypeswithwildcard_4A5_v1"

package/library/packages/services/src/api/metadata/metadata.d.ts

@@ -1,5 +1,18 @@
-import { GetSearchableFieldListResponse, GetSortOrdersResponse, GetSubTypesWithWildcardResponse } from './metadata.types';
+import { GetAllAliasFieldsResponse, GetAllSearchableFieldsForCurrentUserResponse, GetEnabledRelationsResponse, GetSearchableFieldListResponse, GetSortOrdersResponse, GetSubTypesWithWildcardResponse } from './metadata.types';
 
 export declare function apiGetSearchableFieldList(): Promise<never[] | GetSearchableFieldListResponse>;
 export declare function apiGetSortOrders(): Promise<GetSortOrdersResponse>;
+/**
+ * Derives both shapes the UI needs from a single pass over the same `subtypeswithwildcard` payload: `grouped` for
+ * the cascading Type -> Subtype selects, `flat` for flows that need a plain fully-qualified list (e.g. picking the
+ * first wildcard subtype for a new TypeFilters row). Previously these were two separate requests to the same URL,
+ * which required distinct axios-cache-interceptor request ids to avoid the cache treating them as one.
+ */
 export declare function apiGetSubTypesWithWildcard(): Promise<GetSubTypesWithWildcardResponse>;
+export declare function apiGetAllAliasFields(): Promise<GetAllAliasFieldsResponse>;
+/**
+ * Mirrors the React `mapSameFields` transform (`{ value, text }[]` -> `{ id, label }[]`). Not to be confused with
+ * `apiGetSearchableFieldList`, which hits the unrelated `getallobjectfieldsforcurrentuser_4C2_v2` endpoint.
+ */
+export declare function apiGetAllSearchableFieldsForCurrentUser(): Promise<GetAllSearchableFieldsForCurrentUserResponse>;
+export declare function apiGetEnabledRelations(): Promise<GetEnabledRelationsResponse>;

package/library/packages/services/src/api/metadata/metadata.types.d.ts

@@ -32,7 +32,16 @@ export type SubTypeOption = {
  * Outer key: `typeLabel` with spaces replaced by underscores (e.g. `Machine_learning_model`).
  * Inner key: `label`    with spaces replaced by underscores (e.g. `All_Folders`).
  */
-export type GetSubTypesWithWildcardResponse = Record<string, Record<string, SubTypeOption>>;
+export type GroupedSubTypes = Record<string, Record<string, SubTypeOption>>;
+/**
+ * Both shapes derived from the same `subtypeswithwildcard` payload in a single pass: `grouped` for the cascading
+ * Type -> Subtype selects, `flat` (fully-qualified `DO_DOCUMENTS.<typeDbBOName>.<value>` paths, mirroring the React
+ * `concatSubTypes` transform) for flows that need a plain list, e.g. picking the first wildcard subtype.
+ */
+export type GetSubTypesWithWildcardResponse = {
+    flat: SubTypeData[];
+    grouped: GroupedSubTypes;
+};
 export type SortOrderDto = {
     description: string;
     id: string;
@@ -51,3 +60,30 @@ export type GetSortOrdersRawResponse = {
     sortOrders: SortOrderDto[];
 };
 export type GetSortOrdersResponse = SortOrderDto[];
+export type GetAllAliasFieldsRawResponse = {
+    listFields: string[];
+};
+export type GetAllAliasFieldsResponse = string[];
+export type GetAllSearchableFieldsForCurrentUserRawResponse = {
+    listFields: Array<{
+        text: string;
+        value: string;
+    }>;
+};
+export type GetAllSearchableFieldsForCurrentUserResponse = Array<{
+    id: string;
+    label: string;
+}>;
+export type EnabledRelationDto = {
+    childRole: string;
+    childType: string;
+    description: string;
+    id: string;
+    linkType: string;
+    parentRole: string;
+    parentType: string;
+};
+export type GetEnabledRelationsRawResponse = {
+    enabledRelations: EnabledRelationDto[];
+};
+export type GetEnabledRelationsResponse = EnabledRelationDto[];