@luzmo/analytics-components-kit 1.0.9-beta.7 → 1.0.9-beta.8

package/components/item-option/helpers/control-templates/color-range-template.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const colorRangeMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/guidelines-template.d.ts

@@ -0,0 +1,3 @@
+import { ControlMarkupArgs } from '../control-markup';
+/** Render the chart-guidelines control for a configured item option. */
+export declare const guidelinesMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/multi-language-field-template.d.ts

@@ -0,0 +1,8 @@
+import { ControlMarkupArgs } from '../control-markup';
+export interface MultiLanguageFieldArguments {
+    label?: string;
+    value?: Record<string, string>;
+    language?: string;
+    placeholder?: string;
+}
+export declare const multiLanguageFieldMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/number-field-template.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const numberFieldMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/picker-template.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const pickerMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/position-picker-template.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const positionPickerMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/positions-number-field-template.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const positionsNumberFieldMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/radio-button-group.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const radioButtonGroupMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/slider-template.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const sliderMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/switch-template.d.ts

@@ -0,0 +1,2 @@
+import { ControlMarkupArgs } from '../control-markup';
+export declare const switchMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/control-templates/text-field-template.d.ts

@@ -0,0 +1,7 @@
+import { ControlMarkupArgs } from '../control-markup';
+export interface TextFieldArguments {
+    label?: string;
+    value?: string;
+    placeholder?: string;
+}
+export declare const textFieldMarkup: (args: ControlMarkupArgs) => import("lit-html").TemplateResult<1>;

package/components/item-option/helpers/enum-values.d.ts

@@ -0,0 +1,7 @@
+type EnumTranslationMap = Record<string, string> | undefined;
+type EnumValue = string | {
+    label?: unknown;
+};
+type RawEnum = EnumValue[] | Record<string, EnumValue> | null | undefined;
+export declare const buildEnumValues: (rawEnum: RawEnum, translationEnum?: EnumTranslationMap) => Record<string, string>;
+export {};

package/components/item-option/helpers/generate-callback.d.ts

@@ -0,0 +1 @@
+export declare const generateCallback: (args: any) => (e: CustomEvent) => any;

package/components/item-option/helpers/get-control-by-key.d.ts

@@ -0,0 +1 @@
+export declare const getControlByKey: (key: string, config: any[], full?: boolean) => any;

package/components/item-option/helpers/get-default-value.d.ts

@@ -0,0 +1 @@
+export declare const getDefaultValue: (args: any) => any;

package/components/item-option/helpers/get-enum-values.d.ts

@@ -0,0 +1 @@
+export declare const getEnumValues: (args: any) => any;

package/components/item-option/helpers/get-extra-label-values.d.ts

@@ -0,0 +1,7 @@
+import { ControlMarkupArgs } from './control-markup';
+export declare const getExtraLabelValues: (args: ControlMarkupArgs) => {
+    extraLabel: any;
+    extraLabelTooltip: any;
+    extraLabelHasClickAction: any;
+    extraLabelClickAction: () => any;
+};

package/components/item-option/helpers/get-value-by-key.d.ts

@@ -0,0 +1 @@
+export declare const getValueByKey: (args: any, key: string) => any;

package/components/item-option/index.d.ts

@@ -0,0 +1,8 @@
+import { LuzmoItemOption } from './item-option';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option': LuzmoItemOption;
+    }
+}
+export { LuzmoItemOption } from './item-option';
+export type { ItemOptionChangedEventDetail, ItemOptionsChangedEventDetail } from './types';

package/components/item-option/item-option.d.ts

@@ -0,0 +1,59 @@
+import type { OptionConfig, OptionsConfig, OptionTranslation, ThemeConfig, TranslationOverrides, TranslationsFile, VizItemType } from '@luzmo/dashboard-contents-types';
+import { ElementSize, LuzmoElement } from '../../utils/base';
+/**
+ * @customElement luzmo-item-option
+ * @fires {CustomEvent<ItemOptionsChangedEventDetail>} luzmo-options-changed - Announces that the `options` of the element have changed
+ */
+export declare class LuzmoItemOption extends LuzmoElement {
+    static styles: import("lit").CSSResult;
+    private _loadItemConfig;
+    /** The language in which to display the option control. */
+    language: string;
+    /** The visualization item type whose options config and translations are loaded. */
+    itemType?: VizItemType | string;
+    /** The key of the option (within the item type's options config) to render. */
+    optionKey?: string;
+    /** A custom option configuration to render instead of resolving one from `itemType`/`optionKey`. */
+    customOptionConfiguration?: OptionConfig;
+    /** Translation overrides for the option label, tooltip, and enum values. */
+    customTranslations?: OptionTranslation | TranslationOverrides;
+    /** The current option values for the item. */
+    options?: Record<string, unknown>;
+    /** The item's data slots, used by options that depend on slot contents. */
+    slots?: unknown[];
+    /** The theme configuration applied to the option control. */
+    theme?: ThemeConfig & Record<string, any>;
+    /**
+     * The API URL of the databroker
+     * @default https://api.luzmo.com
+     * @description The URL of the databroker API
+     */
+    apiUrl?: string;
+    /**
+     * The auth key of the databroker
+     */
+    authKey?: string;
+    /**
+     * The auth token of the databroker
+     */
+    authToken?: string;
+    /** The size variant of the option control (`s`, `m`, `l`, `xl`). */
+    size: ElementSize;
+    _controlTypeLoaded: string;
+    _itemTypeLoaded?: string;
+    _languageLoaded?: string;
+    _optionsConfig: OptionsConfig;
+    _translations: TranslationsFile;
+    _translationOverrides?: TranslationOverrides;
+    _effectiveTranslations: TranslationsFile;
+    _fullTheme?: any;
+    /** Callback that updates `options` and emits `luzmo-options-changed`; used internally by the rendered control. */
+    changedOptions: (options: any) => void;
+    render(): import("lit-html").TemplateResult<1> | undefined;
+    private _getTranslationOverrides;
+    private _mergeOptionTranslations;
+    private _mergeTranslationValue;
+    private _mergeTranslationRecord;
+    private _getOptionTranslation;
+    private _isOptionTranslation;
+}

package/components/item-option/types.d.ts

@@ -0,0 +1,8 @@
+import type { OptionsConfig } from '@luzmo/dashboard-contents-types';
+export interface ItemOptionChangedEventDetail {
+    value?: unknown;
+    values?: Record<string, number | undefined>;
+}
+export interface ItemOptionsChangedEventDetail {
+    options: OptionsConfig;
+}

package/components/item-option-action-button-group/index.d.ts

@@ -0,0 +1,8 @@
+import { LuzmoItemOptionActionButtonGroup } from './item-option-action-button-group';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option-action-button-group': LuzmoItemOptionActionButtonGroup;
+    }
+}
+export { LuzmoItemOptionActionButtonGroup } from './item-option-action-button-group';
+export type { ItemOptionChangedEventDetail } from '../item-option/types';

package/components/item-option-action-button-group/item-option-action-button-group.d.ts

@@ -0,0 +1,36 @@
+import '@luzmo/lucero/action-button';
+import '@luzmo/lucero/action-group';
+import '@luzmo/lucero/icon';
+import { TemplateResult } from 'lit';
+import { LuzmoItemOptionBase } from '../item-option-base/item-option-base';
+export type ButtonContent = {
+    icon?: {
+        icon: [number, number, string | string[]];
+        name: string;
+    };
+    iconName?: string;
+    label?: string;
+    buttonText?: string;
+};
+/**
+ * @customElement luzmo-item-option-action-button-group
+ * @fires {CustomEvent<ItemOptionChangedEventDetail>} luzmo-option-changed - Emitted when the option value changes.
+ */
+export declare class LuzmoItemOptionActionButtonGroup extends LuzmoItemOptionBase {
+    static styles: (import("lit").CSSResultOrNative | import("lit").CSSResultArray)[];
+    /** The available buttons to choose from (key → button content). */
+    values: Record<string, ButtonContent>;
+    /** Whether the control is disabled (non-interactive). */
+    disabled: boolean;
+    /** Selection mode: `single` or `multiple`. */
+    selects: 'single' | 'multiple' | undefined;
+    /** The currently selected button key(s). */
+    value: [string] | undefined;
+    /** The default selection used when no value is set. */
+    default: [string] | undefined;
+    private actionGroup;
+    private _handleEvent;
+    private _generateButtonContents;
+    private _generateActionButtons;
+    protected renderController(): TemplateResult<1>;
+}

package/components/item-option-base/item-option-base.d.ts

@@ -0,0 +1,23 @@
+import '@luzmo/lucero/field-label';
+import '@luzmo/lucero/tooltip';
+import { CSSResultArray, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+declare const LuzmoItemOptionBase_base: typeof LuzmoElement & {
+    new (...args: any[]): import("../../utils/base/sized-mixin").SizedElementInterface;
+    prototype: import("../../utils/base/sized-mixin").SizedElementInterface;
+};
+export declare abstract class LuzmoItemOptionBase extends LuzmoItemOptionBase_base {
+    static styles: CSSResultArray;
+    disabled: boolean;
+    hideLabel: boolean;
+    label: string;
+    tooltip: string;
+    extraLabel: string;
+    extraLabelHasClickAction: boolean;
+    extraLabelClickAction: any;
+    extraLabelTooltip: string;
+    protected abstract renderController(): TemplateResult;
+    protected handleExtraLabelClick(event?: Event): void;
+    render(): TemplateResult<1>;
+}
+export {};

package/components/item-option-color-palette-picker/index.d.ts

@@ -0,0 +1,8 @@
+import { LuzmoItemOptionColorPalettePicker } from './item-option-color-palette-picker';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option-color-palette-picker': LuzmoItemOptionColorPalettePicker;
+    }
+}
+export { LuzmoItemOptionColorPalettePicker } from './item-option-color-palette-picker';
+export type { ItemOptionChangedEventDetail } from '../item-option/types';

package/components/item-option-color-palette-picker/item-option-color-palette-picker.d.ts

@@ -0,0 +1,46 @@
+import '@luzmo/lucero/color-palette';
+import '@luzmo/lucero/color-palette-group';
+import { TemplateResult } from 'lit';
+import { LuzmoItemOptionBase } from '../item-option-base/item-option-base';
+/**
+ * @customElement luzmo-item-option-color-palette-picker
+ * @fires {CustomEvent<ItemOptionChangedEventDetail>} luzmo-option-changed - Emitted when the option value changes.
+ */
+export declare class LuzmoItemOptionColorPalettePicker extends LuzmoItemOptionBase {
+    static styles: (import("lit").CSSResult | import("lit").CSSResultArray)[];
+    /**
+     * The selected color palette key of the picker
+     */
+    value?: string;
+    /**
+     * The default color palette key of the picker
+     */
+    default: string;
+    /**
+     * The color palette keys of the picker
+     */
+    values: string[];
+    /**
+     * Whether the picker is disabled
+     */
+    disabled: boolean;
+    /**
+     * Whether the picker is horizontal
+     */
+    horizontal: boolean;
+    /**
+     * The function to parse the value
+     */
+    parseValue?: (value: any) => string;
+    /**
+     * The function to convert the value to a string
+     */
+    toValue?: (value: string) => any;
+    /**
+     * The number of colors to display
+     */
+    numberOfColors: number;
+    private _setColorPalette;
+    private generateColorsClasses;
+    protected renderController(): TemplateResult;
+}

package/components/item-option-color-picker/index.d.ts

@@ -0,0 +1,8 @@
+import { LuzmoItemOptionColorPicker } from './item-option-color-picker';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option-color-picker': LuzmoItemOptionColorPicker;
+    }
+}
+export { LuzmoItemOptionColorPicker } from './item-option-color-picker';
+export type { ItemOptionChangedEventDetail } from '../item-option/types';

package/components/item-option-color-picker/item-option-color-picker.d.ts

@@ -0,0 +1,33 @@
+import { Placement } from '@luzmo/lucero';
+import '@luzmo/lucero/color-picker';
+import '@luzmo/lucero/menu';
+import { LuzmoItemOptionBase } from '../item-option-base/item-option-base';
+/**
+ * @customElement luzmo-item-option-color-picker
+ * @description A component that allows the user to select a color from a color picker.
+ * @fires {CustomEvent<ItemOptionChangedEventDetail>} luzmo-option-changed - Emitted when the option value changes.
+ */
+export declare class LuzmoItemOptionColorPicker extends LuzmoItemOptionBase {
+    static styles: import("lit").CSSResultArray[];
+    /** The current color value. */
+    value: string;
+    /** Whether the control is disabled (non-interactive). */
+    disabled: boolean;
+    /** Disables the alpha (opacity) channel in the color picker. */
+    noAlphaChannel: boolean;
+    /** Preset colors offered as quick-pick swatches. */
+    swatches: string[];
+    /** Corner rounding of the color swatch: `full`, `light`, or `none`. */
+    rounding: 'full' | 'light' | 'none';
+    /** Shape of the color swatch: `circle` or `rectangle`. */
+    shape: 'circle' | 'rectangle';
+    /** Placement of the color picker dropdown relative to its trigger. */
+    placement: Placement;
+    /** Delay in milliseconds before the change event is emitted after the user stops interacting. */
+    debounce: number;
+    private colorPicker;
+    /** Internal timer handle used to debounce change events. */
+    debounceTimeout: any;
+    private _handleEvent;
+    protected renderController(): import("lit-html").TemplateResult<1>;
+}

package/components/item-option-color-range/index.d.ts

@@ -0,0 +1,8 @@
+import { LuzmoItemOptionColorRange } from './item-option-color-range';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option-color-range': LuzmoItemOptionColorRange;
+    }
+}
+export { LuzmoItemOptionColorRange } from './item-option-color-range';
+export type { ItemOptionChangedEventDetail } from '../item-option/types';

package/components/item-option-color-range/item-option-color-range.d.ts

@@ -0,0 +1,99 @@
+import '@luzmo/lucero/action-button';
+import '@luzmo/lucero/color-field';
+import '@luzmo/lucero/color-picker';
+import '@luzmo/lucero/icon';
+import '@luzmo/lucero/number-field';
+import '@luzmo/lucero/text-field';
+import { PropertyValues, TemplateResult } from 'lit';
+import { LuzmoItemOptionBase } from '../item-option-base/item-option-base';
+/**
+ * @customElement luzmo-item-option-color-range
+ * @description A component that allows the user to create a color range.
+ * @fires {CustomEvent<ItemOptionChangedEventDetail>} luzmo-option-changed - Emitted when the option value changes.
+ */
+export declare class LuzmoItemOptionColorRange extends LuzmoItemOptionBase {
+    static styles: (import("lit").CSSResult | import("lit").CSSResultArray)[];
+    /**
+     * The color range
+     */
+    value?: {
+        color: string;
+        value?: number;
+    }[];
+    /**
+     * The default color range
+     */
+    default?: {
+        color: string;
+        value?: number;
+    }[];
+    /**
+     * Whether the color-range is disabled
+     * @default false
+     * @type {boolean}
+     */
+    disabled: boolean;
+    /**
+     * Range with percentage values
+     */
+    percentage: boolean;
+    /**
+     * Range colors can have alpha values
+     */
+    noAlphaChannel: boolean;
+    /**
+     * The number of values in the range can be changed
+     */
+    editRangeSize: boolean;
+    /**
+     * The values in the range can be changed by the user in the input field
+     */
+    noValues: boolean;
+    /**
+     * The minimum range size
+     */
+    minimumRangeSize: number;
+    /**
+     * Whether there is a first range value that sets color from negative infinity to the next range value. That first range value has a color, but the value is disregarded
+     */
+    negativeInfinityValue: boolean;
+    /**
+     * The color pickers can be read-only
+     */
+    readOnlyColorPicker: boolean;
+    /**
+     * Whether the colors are reversed
+     */
+    reverse: boolean;
+    /**
+     * The debounce time in milliseconds
+     */
+    debounce: number;
+    /**
+     * The function to parse the value
+     */
+    parseValue?: (value: any) => {
+        color: string;
+        value?: number;
+    }[];
+    /**
+     * The function to convert the value
+     */
+    toValue?: (value: any) => any;
+    private colorRangeLines;
+    /**
+     * @internal
+     */
+    debounceTimeout: any;
+    private _ranges;
+    protected willUpdate(changedProperties: PropertyValues): void;
+    private _handleChangeEvent;
+    private _getIndex;
+    private _extrapolateNewValue;
+    private _setColor;
+    private _setNumber;
+    private _removeRangeValue;
+    private _addRangeValue;
+    private renderRangeValues;
+    protected renderController(): TemplateResult;
+}

package/components/item-option-guidelines/helpers/guidelines-value.d.ts

@@ -0,0 +1,12 @@
+import { type GuidelineLineType, type Guidelines, type GuidelineStyleType, type GuidelineWidth } from '../types';
+export declare const isGuidelineLineType: (value: unknown) => value is GuidelineLineType;
+export declare const resolveLineTypes: (lineTypes?: readonly string[]) => GuidelineLineType[];
+export declare const getDefaultGuidelineColor: (editDarkOrLight?: string) => string;
+export declare const normalizeGuidelines: (raw: unknown) => Guidelines | undefined;
+export declare const addGuidelineLine: (current: Guidelines | undefined, lineTypes: readonly string[] | undefined, defaultColor: string) => Guidelines;
+export declare const removeGuidelineLine: (current: Guidelines, index: number) => Guidelines;
+export declare const setGuidelineLineType: (current: Guidelines, index: number, type: GuidelineLineType) => Guidelines;
+export declare const setGuidelineLineColor: (current: Guidelines, index: number, color: string) => Guidelines;
+export declare const setGuidelineLineValue: (current: Guidelines, index: number, value: number) => Guidelines;
+export declare const setGuidelineStyleType: (current: Guidelines, type: GuidelineStyleType) => Guidelines;
+export declare const setGuidelineStyleWidth: (current: Guidelines, width: GuidelineWidth) => Guidelines;

package/components/item-option-guidelines/index.d.ts

@@ -0,0 +1,10 @@
+import { LuzmoItemOptionGuidelines } from './item-option-guidelines';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option-guidelines': LuzmoItemOptionGuidelines;
+    }
+}
+export { LuzmoItemOptionGuidelines } from './item-option-guidelines';
+export { CARTESIAN_GUIDELINE_LINE_TYPES, DEFAULT_GUIDELINE_COLOR_DARK, DEFAULT_GUIDELINE_COLOR_LIGHT, DEFAULT_GUIDELINE_DEBOUNCE, DEFAULT_GUIDELINE_STYLE, DEFAULT_NUMERIC_GUIDELINE_VALUE, GUIDELINE_LINE_TYPES, GUIDELINE_STYLE_TYPES, GUIDELINE_WIDTHS } from './types';
+export type { GuidelineLine, GuidelineLineType, Guidelines, GuidelineStyle, GuidelineStyleType, GuidelineWidth } from './types';
+export type { ItemOptionChangedEventDetail } from '../item-option/types';

package/components/item-option-guidelines/item-option-guidelines.d.ts

@@ -0,0 +1,74 @@
+import '@luzmo/lucero/action-button';
+import '@luzmo/lucero/action-group';
+import '@luzmo/lucero/button';
+import '@luzmo/lucero/color-picker';
+import '@luzmo/lucero/icon';
+import '@luzmo/lucero/menu';
+import '@luzmo/lucero/number-field';
+import '@luzmo/lucero/picker';
+import { PropertyValues, TemplateResult } from 'lit';
+import { LuzmoItemOptionBase } from '../item-option-base/item-option-base';
+import { type Guidelines } from './types';
+declare const LocalizedItemOptionBase: (new (...args: any[]) => {
+    language: string;
+}) & (new () => LuzmoItemOptionBase) & typeof LuzmoItemOptionBase;
+/**
+ * @customElement luzmo-item-option-guidelines
+ * @description Editor for chart guideline (reference line) options: add, update, and delete lines, plus shared style and width.
+ * @fires {CustomEvent<ItemOptionChangedEventDetail>} luzmo-option-changed - Emitted when the guidelines value changes.
+ * @cssprop --luzmo-item-option-guidelines-rows-gap - Gap between guideline rows.
+ * @cssprop --luzmo-item-option-guidelines-row-gap - Gap between controls in a guideline row.
+ * @cssprop --luzmo-item-option-guidelines-shared-gap - Gap between the line list and the shared style/width controls.
+ */
+export declare class LuzmoItemOptionGuidelines extends LocalizedItemOptionBase {
+    static get styles(): (import("lit").CSSResultOrNative | import("lit").CSSResultArray)[];
+    /**
+     * The current guidelines value (`lines` plus shared `style`).
+     */
+    value?: Guidelines;
+    /**
+     * Allowed guideline calculation types for this chart (from the option config enum).
+     */
+    lineTypes: string[];
+    /**
+     * Display labels for guideline types (key → label). Missing keys fall back to built-in copy.
+     */
+    lineTypeLabels: Record<string, string>;
+    /**
+     * Default color used when adding a guideline.
+     */
+    defaultColor: string;
+    /**
+     * Delay in milliseconds before color and number changes are emitted.
+     */
+    debounce: number;
+    private _guidelines?;
+    private _debounceTimeout?;
+    private _lineIds;
+    private _lineIdCounter;
+    private readonly _styleLabelId;
+    private readonly _widthLabelId;
+    protected willUpdate(changedProperties: PropertyValues): void;
+    disconnectedCallback(): void;
+    private _createLineId;
+    private _clearDebounce;
+    private _emit;
+    private _commit;
+    private _allowedTypes;
+    private _typeLabel;
+    private _typeValues;
+    private _widthValues;
+    private _styleOptions;
+    private _handleAdd;
+    private _handleRemove;
+    private _handleTypeChange;
+    private _handleColorChange;
+    private _handleValueChange;
+    private _handleStyleChange;
+    private _handleWidthChange;
+    private _lineKey;
+    private _renderLine;
+    private _renderSharedStyle;
+    protected renderController(): TemplateResult;
+}
+export {};

package/components/item-option-guidelines/types.d.ts

@@ -0,0 +1,25 @@
+export declare const GUIDELINE_LINE_TYPES: readonly ["value", "average", "median", "average open", "average close"];
+export type GuidelineLineType = (typeof GUIDELINE_LINE_TYPES)[number];
+export declare const GUIDELINE_STYLE_TYPES: readonly ["0", "1,2", "3,3"];
+export type GuidelineStyleType = (typeof GUIDELINE_STYLE_TYPES)[number];
+export declare const GUIDELINE_WIDTHS: readonly ["1", "2", "3"];
+export type GuidelineWidth = (typeof GUIDELINE_WIDTHS)[number];
+export declare const CARTESIAN_GUIDELINE_LINE_TYPES: readonly ["value", "average", "median"];
+export declare const DEFAULT_GUIDELINE_STYLE: GuidelineStyle;
+export declare const DEFAULT_GUIDELINE_COLOR_LIGHT = "rgba(0, 0, 0, 0.3)";
+export declare const DEFAULT_GUIDELINE_COLOR_DARK = "rgba(255, 255, 255, 0.7)";
+export declare const DEFAULT_NUMERIC_GUIDELINE_VALUE = 0;
+export declare const DEFAULT_GUIDELINE_DEBOUNCE = 200;
+export interface GuidelineLine {
+    color: string;
+    type: GuidelineLineType;
+    value?: number;
+}
+export interface GuidelineStyle {
+    type: GuidelineStyleType;
+    width: GuidelineWidth;
+}
+export interface Guidelines {
+    lines: GuidelineLine[];
+    style: GuidelineStyle;
+}

package/components/item-option-multi-language-field/index.d.ts

@@ -0,0 +1,8 @@
+import { LuzmoItemOptionMultiLangField } from './item-option-multi-language-field';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option-multi-language-field': LuzmoItemOptionMultiLangField;
+    }
+}
+export { LuzmoItemOptionMultiLangField } from './item-option-multi-language-field';
+export type { ItemOptionChangedEventDetail } from '../item-option/types';

package/components/item-option-multi-language-field/item-option-multi-language-field.d.ts

@@ -0,0 +1,30 @@
+import '@luzmo/lucero/multi-language-field';
+import { LuzmoItemOptionBase } from '../item-option-base/item-option-base';
+/**
+ * @customElement luzmo-item-option-multi-language-field
+ * @fires {CustomEvent<ItemOptionChangedEventDetail>} luzmo-option-changed - Emitted when the option value changes.
+ */
+export declare class LuzmoItemOptionMultiLangField extends LuzmoItemOptionBase {
+    static styles: import("lit").CSSResultArray[];
+    /** The current value per language (language code → text). */
+    value: Record<string, string>;
+    /** Whether the control is shown in an invalid state. */
+    invalid: boolean;
+    /** Whether the control is read-only. */
+    readonly: boolean;
+    /** The active language whose value is currently edited. */
+    language?: string;
+    /** Placeholder text per language (language code → text) shown when empty. */
+    placeholder?: Record<string, string>;
+    /** Optional transform applied to the stored value before it is displayed in the control. */
+    parseValue?: (value: any, language: string) => any;
+    /** Optional transform applied to the control's value before it is emitted in the change event. */
+    toValue?: (value: any, language: string) => any;
+    /** Delay in milliseconds before the change event is emitted after the user stops interacting. */
+    debounce: number;
+    private multiLangFieldElement;
+    /** Internal timer handle used to debounce change events. */
+    debounceTimeout: any;
+    private _handleEvent;
+    protected renderController(): import("lit-html").TemplateResult<1>;
+}

package/components/item-option-number-field/index.d.ts

@@ -0,0 +1,8 @@
+import { LuzmoItemOptionNumberField } from './item-option-number-field';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-item-option-number-field': LuzmoItemOptionNumberField;
+    }
+}
+export { LuzmoItemOptionNumberField } from './item-option-number-field';
+export type { ItemOptionChangedEventDetail } from '../item-option/types';