@luzmo/analytics-components-kit 1.0.6 → 1.0.8-beta.1

package/react/esm/components/data-field-level.component.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDataFieldLevel as LuzmoDataFieldLevelClass } from '@luzmo/analytics-components-kit/data-field-level';
+const LuzmoDataFieldLevelComponent = createComponent({
+    tagName: 'luzmo-data-field-level',
+    elementClass: LuzmoDataFieldLevelClass,
+    react: React,
+    events: {
+        onLuzmoDataFieldDropped: 'luzmo-data-field-dropped',
+        onLuzmoDataFieldDragStarted: 'luzmo-data-field-drag-started'
+    }
+});
+/**
+ * React wrapper for <luzmo-data-field-level>
+ *
+ * @event onLuzmoDataFieldDropped - Announces that the data field has been dropped
+ * @event onLuzmoDataFieldDragStarted - Announces that the drag is started on the data field
+ */
+export const LuzmoDataFieldLevel = LuzmoDataFieldLevelComponent;

package/react/esm/components/data-fields-select.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDataFieldsSelect as LuzmoDataFieldsSelectClass, DataFieldsSelectedEventDetail } from '@luzmo/analytics-components-kit/data-fields-select';
+/**
+ * React wrapper for <luzmo-data-fields-select>
+ *
+ * @event onLuzmoDataFieldsSelected - Emitted when data fields are selected
+ */
+export declare const LuzmoDataFieldsSelect: ReactWebComponent<LuzmoDataFieldsSelectClass, {
+    onLuzmoDataFieldsSelected: EventName<CustomEvent<DataFieldsSelectedEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoDataFieldsSelect */
+export type LuzmoDataFieldsSelectElement = LuzmoDataFieldsSelectClass;

package/react/esm/components/data-fields-select.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDataFieldsSelect as LuzmoDataFieldsSelectClass } from '@luzmo/analytics-components-kit/data-fields-select';
+const LuzmoDataFieldsSelectComponent = createComponent({
+    tagName: 'luzmo-data-fields-select',
+    elementClass: LuzmoDataFieldsSelectClass,
+    react: React,
+    events: {
+        onLuzmoDataFieldsSelected: 'luzmo-data-fields-selected'
+    }
+});
+/**
+ * React wrapper for <luzmo-data-fields-select>
+ *
+ * @event onLuzmoDataFieldsSelected - Emitted when data fields are selected
+ */
+export const LuzmoDataFieldsSelect = LuzmoDataFieldsSelectComponent;

package/react/esm/components/dataset-icon.component.d.ts

@@ -0,0 +1,8 @@
+import { ReactWebComponent } from '@lit/react';
+import { LuzmoDatasetIcon as LuzmoDatasetIconClass } from '@luzmo/analytics-components-kit/dataset-icon';
+/**
+ * React wrapper for <luzmo-dataset-icon>
+ */
+export declare const LuzmoDatasetIcon: ReactWebComponent<LuzmoDatasetIconClass>;
+/** The underlying custom element type for LuzmoDatasetIcon */
+export type LuzmoDatasetIconElement = LuzmoDatasetIconClass;

package/react/esm/components/dataset-icon.component.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDatasetIcon as LuzmoDatasetIconClass } from '@luzmo/analytics-components-kit/dataset-icon';
+const LuzmoDatasetIconComponent = createComponent({
+    tagName: 'luzmo-dataset-icon',
+    elementClass: LuzmoDatasetIconClass,
+    react: React,
+    events: {}
+});
+/**
+ * React wrapper for <luzmo-dataset-icon>
+ */
+export const LuzmoDatasetIcon = LuzmoDatasetIconComponent;

package/react/esm/components/dataset-selector-list.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDatasetSelectorList as LuzmoDatasetSelectorListClass, Dataset } from '@luzmo/analytics-components-kit/dataset-selector-list';
+/**
+ * React wrapper for <luzmo-dataset-selector-list>
+ *
+ * @event onDatasetSelected - Fired when a dataset is selected
+ */
+export declare const LuzmoDatasetSelectorList: ReactWebComponent<LuzmoDatasetSelectorListClass, {
+    onDatasetSelected: EventName<CustomEvent<Dataset>>;
+}>;
+/** The underlying custom element type for LuzmoDatasetSelectorList */
+export type LuzmoDatasetSelectorListElement = LuzmoDatasetSelectorListClass;

package/react/esm/components/dataset-selector-list.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDatasetSelectorList as LuzmoDatasetSelectorListClass } from '@luzmo/analytics-components-kit/dataset-selector-list';
+const LuzmoDatasetSelectorListComponent = createComponent({
+    tagName: 'luzmo-dataset-selector-list',
+    elementClass: LuzmoDatasetSelectorListClass,
+    react: React,
+    events: {
+        onDatasetSelected: 'dataset-selected'
+    }
+});
+/**
+ * React wrapper for <luzmo-dataset-selector-list>
+ *
+ * @event onDatasetSelected - Fired when a dataset is selected
+ */
+export const LuzmoDatasetSelectorList = LuzmoDatasetSelectorListComponent;

package/react/esm/components/dataset-selector-row.component.d.ts

@@ -0,0 +1,14 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDatasetSelectorRow as LuzmoDatasetSelectorRowClass, Dataset } from '@luzmo/analytics-components-kit/dataset-selector-row';
+/**
+ * React wrapper for <luzmo-dataset-selector-row>
+ *
+ * @event onDatasetSelected - Fired when a dataset is selected
+ * @event onDatasetRemoved - Fired when a dataset is removed
+ */
+export declare const LuzmoDatasetSelectorRow: ReactWebComponent<LuzmoDatasetSelectorRowClass, {
+    onDatasetSelected: EventName<CustomEvent<Dataset>>;
+    onDatasetRemoved: EventName<CustomEvent<Dataset>>;
+}>;
+/** The underlying custom element type for LuzmoDatasetSelectorRow */
+export type LuzmoDatasetSelectorRowElement = LuzmoDatasetSelectorRowClass;

package/react/esm/components/dataset-selector-row.component.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDatasetSelectorRow as LuzmoDatasetSelectorRowClass } from '@luzmo/analytics-components-kit/dataset-selector-row';
+const LuzmoDatasetSelectorRowComponent = createComponent({
+    tagName: 'luzmo-dataset-selector-row',
+    elementClass: LuzmoDatasetSelectorRowClass,
+    react: React,
+    events: {
+        onDatasetSelected: 'dataset-selected',
+        onDatasetRemoved: 'dataset-removed'
+    }
+});
+/**
+ * React wrapper for <luzmo-dataset-selector-row>
+ *
+ * @event onDatasetSelected - Fired when a dataset is selected
+ * @event onDatasetRemoved - Fired when a dataset is removed
+ */
+export const LuzmoDatasetSelectorRow = LuzmoDatasetSelectorRowComponent;

package/react/esm/components/display-settings-binning.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDisplaySettingsBinning as LuzmoDisplaySettingsBinningClass, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-binning';
+/**
+ * React wrapper for <luzmo-display-settings-binning>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export declare const LuzmoDisplaySettingsBinning: ReactWebComponent<LuzmoDisplaySettingsBinningClass, {
+    onLuzmoSlotContentChanged: EventName<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoDisplaySettingsBinning */
+export type LuzmoDisplaySettingsBinningElement = LuzmoDisplaySettingsBinningClass;

package/react/esm/components/display-settings-binning.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDisplaySettingsBinning as LuzmoDisplaySettingsBinningClass } from '@luzmo/analytics-components-kit/display-settings-binning';
+const LuzmoDisplaySettingsBinningComponent = createComponent({
+    tagName: 'luzmo-display-settings-binning',
+    elementClass: LuzmoDisplaySettingsBinningClass,
+    react: React,
+    events: {
+        onLuzmoSlotContentChanged: 'luzmo-slot-content-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-display-settings-binning>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export const LuzmoDisplaySettingsBinning = LuzmoDisplaySettingsBinningComponent;

package/react/esm/components/display-settings-datetime.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDisplaySettingsDatetime as LuzmoDisplaySettingsDatetimeClass, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-datetime';
+/**
+ * React wrapper for <luzmo-display-settings-datetime>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export declare const LuzmoDisplaySettingsDatetime: ReactWebComponent<LuzmoDisplaySettingsDatetimeClass, {
+    onLuzmoSlotContentChanged: EventName<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoDisplaySettingsDatetime */
+export type LuzmoDisplaySettingsDatetimeElement = LuzmoDisplaySettingsDatetimeClass;

package/react/esm/components/display-settings-datetime.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDisplaySettingsDatetime as LuzmoDisplaySettingsDatetimeClass } from '@luzmo/analytics-components-kit/display-settings-datetime';
+const LuzmoDisplaySettingsDatetimeComponent = createComponent({
+    tagName: 'luzmo-display-settings-datetime',
+    elementClass: LuzmoDisplaySettingsDatetimeClass,
+    react: React,
+    events: {
+        onLuzmoSlotContentChanged: 'luzmo-slot-content-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-display-settings-datetime>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export const LuzmoDisplaySettingsDatetime = LuzmoDisplaySettingsDatetimeComponent;

package/react/esm/components/display-settings-grand-totals.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDisplaySettingsGrandTotals as LuzmoDisplaySettingsGrandTotalsClass, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-grand-totals';
+/**
+ * React wrapper for <luzmo-display-settings-grand-totals>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export declare const LuzmoDisplaySettingsGrandTotals: ReactWebComponent<LuzmoDisplaySettingsGrandTotalsClass, {
+    onLuzmoSlotContentChanged: EventName<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoDisplaySettingsGrandTotals */
+export type LuzmoDisplaySettingsGrandTotalsElement = LuzmoDisplaySettingsGrandTotalsClass;

package/react/esm/components/display-settings-grand-totals.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDisplaySettingsGrandTotals as LuzmoDisplaySettingsGrandTotalsClass } from '@luzmo/analytics-components-kit/display-settings-grand-totals';
+const LuzmoDisplaySettingsGrandTotalsComponent = createComponent({
+    tagName: 'luzmo-display-settings-grand-totals',
+    elementClass: LuzmoDisplaySettingsGrandTotalsClass,
+    react: React,
+    events: {
+        onLuzmoSlotContentChanged: 'luzmo-slot-content-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-display-settings-grand-totals>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export const LuzmoDisplaySettingsGrandTotals = LuzmoDisplaySettingsGrandTotalsComponent;

package/react/esm/components/display-settings-numeric.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDisplaySettingsNumeric as LuzmoDisplaySettingsNumericClass, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-numeric';
+/**
+ * React wrapper for <luzmo-display-settings-numeric>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export declare const LuzmoDisplaySettingsNumeric: ReactWebComponent<LuzmoDisplaySettingsNumericClass, {
+    onLuzmoSlotContentChanged: EventName<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoDisplaySettingsNumeric */
+export type LuzmoDisplaySettingsNumericElement = LuzmoDisplaySettingsNumericClass;

package/react/esm/components/display-settings-numeric.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDisplaySettingsNumeric as LuzmoDisplaySettingsNumericClass } from '@luzmo/analytics-components-kit/display-settings-numeric';
+const LuzmoDisplaySettingsNumericComponent = createComponent({
+    tagName: 'luzmo-display-settings-numeric',
+    elementClass: LuzmoDisplaySettingsNumericClass,
+    react: React,
+    events: {
+        onLuzmoSlotContentChanged: 'luzmo-slot-content-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-display-settings-numeric>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export const LuzmoDisplaySettingsNumeric = LuzmoDisplaySettingsNumericComponent;

package/react/esm/components/display-settings-period-over-period.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDisplaySettingsPeriodOverPeriod as LuzmoDisplaySettingsPeriodOverPeriodClass, DisplaySettingsSlotContentChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings-period-over-period';
+/**
+ * React wrapper for <luzmo-display-settings-period-over-period>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export declare const LuzmoDisplaySettingsPeriodOverPeriod: ReactWebComponent<LuzmoDisplaySettingsPeriodOverPeriodClass, {
+    onLuzmoSlotContentChanged: EventName<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoDisplaySettingsPeriodOverPeriod */
+export type LuzmoDisplaySettingsPeriodOverPeriodElement = LuzmoDisplaySettingsPeriodOverPeriodClass;

package/react/esm/components/display-settings-period-over-period.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDisplaySettingsPeriodOverPeriod as LuzmoDisplaySettingsPeriodOverPeriodClass } from '@luzmo/analytics-components-kit/display-settings-period-over-period';
+const LuzmoDisplaySettingsPeriodOverPeriodComponent = createComponent({
+    tagName: 'luzmo-display-settings-period-over-period',
+    elementClass: LuzmoDisplaySettingsPeriodOverPeriodClass,
+    react: React,
+    events: {
+        onLuzmoSlotContentChanged: 'luzmo-slot-content-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-display-settings-period-over-period>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ */
+export const LuzmoDisplaySettingsPeriodOverPeriod = LuzmoDisplaySettingsPeriodOverPeriodComponent;

package/react/esm/components/display-settings.component.d.ts

@@ -0,0 +1,16 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoDisplaySettings as LuzmoDisplaySettingsClass, DisplaySettingsRemoveSlotContentEventDetail, DisplaySettingsSlotContentChangedEventDetail, InfoVisibilityChangedEventDetail } from '@luzmo/analytics-components-kit/display-settings';
+/**
+ * React wrapper for <luzmo-display-settings>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ * @event onLuzmoRemoveSlotContent - Event that is fired when the remove button is clicked
+ * @event onLuzmoInfoVisibilityChanged - Event that is fired when the info button is clicked, includes the visibility state and ID values
+ */
+export declare const LuzmoDisplaySettings: ReactWebComponent<LuzmoDisplaySettingsClass, {
+    onLuzmoSlotContentChanged: EventName<CustomEvent<DisplaySettingsSlotContentChangedEventDetail>>;
+    onLuzmoRemoveSlotContent: EventName<CustomEvent<DisplaySettingsRemoveSlotContentEventDetail>>;
+    onLuzmoInfoVisibilityChanged: EventName<CustomEvent<InfoVisibilityChangedEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoDisplaySettings */
+export type LuzmoDisplaySettingsElement = LuzmoDisplaySettingsClass;

package/react/esm/components/display-settings.component.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoDisplaySettings as LuzmoDisplaySettingsClass } from '@luzmo/analytics-components-kit/display-settings';
+const LuzmoDisplaySettingsComponent = createComponent({
+    tagName: 'luzmo-display-settings',
+    elementClass: LuzmoDisplaySettingsClass,
+    react: React,
+    events: {
+        onLuzmoSlotContentChanged: 'luzmo-slot-content-changed',
+        onLuzmoRemoveSlotContent: 'luzmo-remove-slot-content',
+        onLuzmoInfoVisibilityChanged: 'luzmo-info-visibility-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-display-settings>
+ *
+ * @event onLuzmoSlotContentChanged - Event that is fired when the slot content is changed
+ * @event onLuzmoRemoveSlotContent - Event that is fired when the remove button is clicked
+ * @event onLuzmoInfoVisibilityChanged - Event that is fired when the info button is clicked, includes the visibility state and ID values
+ */
+export const LuzmoDisplaySettings = LuzmoDisplaySettingsComponent;

package/react/esm/components/filter-expression-picker.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoFilterExpressionPicker as LuzmoFilterExpressionPickerClass } from '@luzmo/analytics-components-kit/filter-expression-picker';
+/**
+ * React wrapper for <luzmo-filter-expression-picker>
+ *
+ * @event onLuzmoExpressionSelected - Fired when the user selects a filter expression (operator); `detail.expression` holds the chosen expression.
+ */
+export declare const LuzmoFilterExpressionPicker: ReactWebComponent<LuzmoFilterExpressionPickerClass, {
+    onLuzmoExpressionSelected: EventName<CustomEvent>;
+}>;
+/** The underlying custom element type for LuzmoFilterExpressionPicker */
+export type LuzmoFilterExpressionPickerElement = LuzmoFilterExpressionPickerClass;

package/react/esm/components/filter-expression-picker.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoFilterExpressionPicker as LuzmoFilterExpressionPickerClass } from '@luzmo/analytics-components-kit/filter-expression-picker';
+const LuzmoFilterExpressionPickerComponent = createComponent({
+    tagName: 'luzmo-filter-expression-picker',
+    elementClass: LuzmoFilterExpressionPickerClass,
+    react: React,
+    events: {
+        onLuzmoExpressionSelected: 'luzmo-expression-selected'
+    }
+});
+/**
+ * React wrapper for <luzmo-filter-expression-picker>
+ *
+ * @event onLuzmoExpressionSelected - Fired when the user selects a filter expression (operator); `detail.expression` holds the chosen expression.
+ */
+export const LuzmoFilterExpressionPicker = LuzmoFilterExpressionPickerComponent;

package/react/esm/components/filter-item.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoFilterItem as LuzmoFilterItemClass } from '@luzmo/analytics-components-kit/filter-item';
+/**
+ * React wrapper for <luzmo-filter-item>
+ *
+ * @event onLuzmoFilterChanged - Fired when any part of the filter changes; `detail.filter` holds the updated filter.
+ */
+export declare const LuzmoFilterItem: ReactWebComponent<LuzmoFilterItemClass, {
+    onLuzmoFilterChanged: EventName<CustomEvent>;
+}>;
+/** The underlying custom element type for LuzmoFilterItem */
+export type LuzmoFilterItemElement = LuzmoFilterItemClass;

package/react/esm/components/filter-item.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoFilterItem as LuzmoFilterItemClass } from '@luzmo/analytics-components-kit/filter-item';
+const LuzmoFilterItemComponent = createComponent({
+    tagName: 'luzmo-filter-item',
+    elementClass: LuzmoFilterItemClass,
+    react: React,
+    events: {
+        onLuzmoFilterChanged: 'luzmo-filter-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-filter-item>
+ *
+ * @event onLuzmoFilterChanged - Fired when any part of the filter changes; `detail.filter` holds the updated filter.
+ */
+export const LuzmoFilterItem = LuzmoFilterItemComponent;

package/react/esm/components/filter-parameter-picker.component.d.ts

@@ -0,0 +1,16 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoFilterParameterPicker as LuzmoFilterParameterPickerClass, FilterParameterPickerEventDetail } from '@luzmo/analytics-components-kit/filter-parameter-picker';
+/**
+ * React wrapper for <luzmo-filter-parameter-picker>
+ *
+ * @event onLuzmoParameterSelected - Fired when a parameter is selected.
+ * @event onLuzmoParameterCreated - Fired when a parameter is created.
+ * @event onLuzmoParameterRemoved - Fired when a parameter is detached from the filter.
+ */
+export declare const LuzmoFilterParameterPicker: ReactWebComponent<LuzmoFilterParameterPickerClass, {
+    onLuzmoParameterSelected: EventName<CustomEvent<FilterParameterPickerEventDetail>>;
+    onLuzmoParameterCreated: EventName<CustomEvent<FilterParameterPickerEventDetail>>;
+    onLuzmoParameterRemoved: EventName<CustomEvent<FilterParameterPickerEventDetail>>;
+}>;
+/** The underlying custom element type for LuzmoFilterParameterPicker */
+export type LuzmoFilterParameterPickerElement = LuzmoFilterParameterPickerClass;

package/react/esm/components/filter-parameter-picker.component.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoFilterParameterPicker as LuzmoFilterParameterPickerClass } from '@luzmo/analytics-components-kit/filter-parameter-picker';
+const LuzmoFilterParameterPickerComponent = createComponent({
+    tagName: 'luzmo-filter-parameter-picker',
+    elementClass: LuzmoFilterParameterPickerClass,
+    react: React,
+    events: {
+        onLuzmoParameterSelected: 'luzmo-parameter-selected',
+        onLuzmoParameterCreated: 'luzmo-parameter-created',
+        onLuzmoParameterRemoved: 'luzmo-parameter-removed'
+    }
+});
+/**
+ * React wrapper for <luzmo-filter-parameter-picker>
+ *
+ * @event onLuzmoParameterSelected - Fired when a parameter is selected.
+ * @event onLuzmoParameterCreated - Fired when a parameter is created.
+ * @event onLuzmoParameterRemoved - Fired when a parameter is detached from the filter.
+ */
+export const LuzmoFilterParameterPicker = LuzmoFilterParameterPickerComponent;

package/react/esm/components/filter-value-picker-datetime.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoFilterValuePickerDatetime as LuzmoFilterValuePickerDatetimeClass } from '@luzmo/analytics-components-kit/filter-value-picker-datetime';
+/**
+ * React wrapper for <luzmo-filter-value-picker-datetime>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the datetime filter value changes; `detail.value` holds the new value (ISO date or relative range).
+ */
+export declare const LuzmoFilterValuePickerDatetime: ReactWebComponent<LuzmoFilterValuePickerDatetimeClass, {
+    onLuzmoFilterValueChanged: EventName<CustomEvent>;
+}>;
+/** The underlying custom element type for LuzmoFilterValuePickerDatetime */
+export type LuzmoFilterValuePickerDatetimeElement = LuzmoFilterValuePickerDatetimeClass;

package/react/esm/components/filter-value-picker-datetime.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoFilterValuePickerDatetime as LuzmoFilterValuePickerDatetimeClass } from '@luzmo/analytics-components-kit/filter-value-picker-datetime';
+const LuzmoFilterValuePickerDatetimeComponent = createComponent({
+    tagName: 'luzmo-filter-value-picker-datetime',
+    elementClass: LuzmoFilterValuePickerDatetimeClass,
+    react: React,
+    events: {
+        onLuzmoFilterValueChanged: 'luzmo-filter-value-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-filter-value-picker-datetime>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the datetime filter value changes; `detail.value` holds the new value (ISO date or relative range).
+ */
+export const LuzmoFilterValuePickerDatetime = LuzmoFilterValuePickerDatetimeComponent;

package/react/esm/components/filter-value-picker-hierarchy.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoFilterValuePickerHierarchy as LuzmoFilterValuePickerHierarchyClass } from '@luzmo/analytics-components-kit/filter-value-picker-hierarchy';
+/**
+ * React wrapper for <luzmo-filter-value-picker-hierarchy>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the hierarchy filter value changes; `detail.value` holds the selected value(s).
+ */
+export declare const LuzmoFilterValuePickerHierarchy: ReactWebComponent<LuzmoFilterValuePickerHierarchyClass, {
+    onLuzmoFilterValueChanged: EventName<CustomEvent>;
+}>;
+/** The underlying custom element type for LuzmoFilterValuePickerHierarchy */
+export type LuzmoFilterValuePickerHierarchyElement = LuzmoFilterValuePickerHierarchyClass;

package/react/esm/components/filter-value-picker-hierarchy.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoFilterValuePickerHierarchy as LuzmoFilterValuePickerHierarchyClass } from '@luzmo/analytics-components-kit/filter-value-picker-hierarchy';
+const LuzmoFilterValuePickerHierarchyComponent = createComponent({
+    tagName: 'luzmo-filter-value-picker-hierarchy',
+    elementClass: LuzmoFilterValuePickerHierarchyClass,
+    react: React,
+    events: {
+        onLuzmoFilterValueChanged: 'luzmo-filter-value-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-filter-value-picker-hierarchy>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the hierarchy filter value changes; `detail.value` holds the selected value(s).
+ */
+export const LuzmoFilterValuePickerHierarchy = LuzmoFilterValuePickerHierarchyComponent;

package/react/esm/components/filter-value-picker-numeric.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoFilterValuePickerNumeric as LuzmoFilterValuePickerNumericClass } from '@luzmo/analytics-components-kit/filter-value-picker-numeric';
+/**
+ * React wrapper for <luzmo-filter-value-picker-numeric>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the numeric filter value changes; `detail.value` holds the new number or range.
+ */
+export declare const LuzmoFilterValuePickerNumeric: ReactWebComponent<LuzmoFilterValuePickerNumericClass, {
+    onLuzmoFilterValueChanged: EventName<CustomEvent>;
+}>;
+/** The underlying custom element type for LuzmoFilterValuePickerNumeric */
+export type LuzmoFilterValuePickerNumericElement = LuzmoFilterValuePickerNumericClass;

package/react/esm/components/filter-value-picker-numeric.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoFilterValuePickerNumeric as LuzmoFilterValuePickerNumericClass } from '@luzmo/analytics-components-kit/filter-value-picker-numeric';
+const LuzmoFilterValuePickerNumericComponent = createComponent({
+    tagName: 'luzmo-filter-value-picker-numeric',
+    elementClass: LuzmoFilterValuePickerNumericClass,
+    react: React,
+    events: {
+        onLuzmoFilterValueChanged: 'luzmo-filter-value-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-filter-value-picker-numeric>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the numeric filter value changes; `detail.value` holds the new number or range.
+ */
+export const LuzmoFilterValuePickerNumeric = LuzmoFilterValuePickerNumericComponent;

package/react/esm/components/filter-value-picker.component.d.ts

@@ -0,0 +1,12 @@
+import { EventName, ReactWebComponent } from '@lit/react';
+import { LuzmoFilterValuePicker as LuzmoFilterValuePickerClass } from '@luzmo/analytics-components-kit/filter-value-picker';
+/**
+ * React wrapper for <luzmo-filter-value-picker>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the filter value changes; `detail.value` holds the new value.
+ */
+export declare const LuzmoFilterValuePicker: ReactWebComponent<LuzmoFilterValuePickerClass, {
+    onLuzmoFilterValueChanged: EventName<CustomEvent>;
+}>;
+/** The underlying custom element type for LuzmoFilterValuePicker */
+export type LuzmoFilterValuePickerElement = LuzmoFilterValuePickerClass;

package/react/esm/components/filter-value-picker.component.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createComponent } from '@lit/react';
+import { LuzmoFilterValuePicker as LuzmoFilterValuePickerClass } from '@luzmo/analytics-components-kit/filter-value-picker';
+const LuzmoFilterValuePickerComponent = createComponent({
+    tagName: 'luzmo-filter-value-picker',
+    elementClass: LuzmoFilterValuePickerClass,
+    react: React,
+    events: {
+        onLuzmoFilterValueChanged: 'luzmo-filter-value-changed'
+    }
+});
+/**
+ * React wrapper for <luzmo-filter-value-picker>
+ *
+ * @event onLuzmoFilterValueChanged - Fired when the filter value changes; `detail.value` holds the new value.
+ */
+export const LuzmoFilterValuePicker = LuzmoFilterValuePickerComponent;

package/react/esm/components/filters.component.d.ts

@@ -1,12 +1,20 @@
 import { EventName, ReactWebComponent } from '@lit/react';
-import { LuzmoFilters as LuzmoFiltersClass, FiltersChangedEventDetail } from '@luzmo/analytics-components-kit/filters';
+import { LuzmoFilters as LuzmoFiltersClass, FilterParameter, FiltersChangedEventDetail } from '@luzmo/analytics-components-kit/filters';
 /**
  * React wrapper for <luzmo-filters>
  *
- * @event onLuzmoFiltersChanged - Announces that the filters have changed
+ * @event onLuzmoFiltersChanged - Announces that the filters have changed, carrying the emitted groups and the format they are in
+ * @event onLuzmoParameterCreated - Announces that a parameter was created and added to `parameters`.
+ * @event onLuzmoParameterRemoved - Announces that a parameter was detached from a filter.
  */
 export declare const LuzmoFilters: ReactWebComponent<LuzmoFiltersClass, {
     onLuzmoFiltersChanged: EventName<CustomEvent<FiltersChangedEventDetail>>;
+    onLuzmoParameterCreated: EventName<CustomEvent<{
+        parameter: FilterParameter;
+    }>>;
+    onLuzmoParameterRemoved: EventName<CustomEvent<{
+        parameter: FilterParameter;
+    }>>;
 }>;
 /** The underlying custom element type for LuzmoFilters */
 export type LuzmoFiltersElement = LuzmoFiltersClass;

package/react/esm/components/filters.component.js

@@ -6,12 +6,16 @@ const LuzmoFiltersComponent = createComponent({
     elementClass: LuzmoFiltersClass,
     react: React,
     events: {
-        onLuzmoFiltersChanged: 'luzmo-filters-changed'
+        onLuzmoFiltersChanged: 'luzmo-filters-changed',
+        onLuzmoParameterCreated: 'luzmo-parameter-created',
+        onLuzmoParameterRemoved: 'luzmo-parameter-removed'
     }
 });
 /**
  * React wrapper for <luzmo-filters>
  *
- * @event onLuzmoFiltersChanged - Announces that the filters have changed
+ * @event onLuzmoFiltersChanged - Announces that the filters have changed, carrying the emitted groups and the format they are in
+ * @event onLuzmoParameterCreated - Announces that a parameter was created and added to `parameters`.
+ * @event onLuzmoParameterRemoved - Announces that a parameter was detached from a filter.
  */
 export const LuzmoFilters = LuzmoFiltersComponent;