@arcgis/common-components 4.29.0-test.0 → 5.0.0-next.113

package/dist/components/arcgis-slider/index.d.ts

@@ -0,0 +1,3 @@
+import "@esri/calcite-components/components/calcite-popover";
+import "../arcgis-label-input/index.js";
+export * from "./customElement.js";

package/dist/components/arcgis-slider/index.js

@@ -0,0 +1,3 @@
+import "@esri/calcite-components/components/calcite-popover";
+import "../arcgis-label-input/index.js";
+export * from "./customElement.js";

package/dist/components/arcgis-slider/stepsUtils.d.ts

@@ -0,0 +1,52 @@
+import { UUID } from '@arcgis/toolkit/string';
+export interface StepsInfo {
+    min: number;
+    max: number;
+    steps?: number[] | number;
+}
+export interface StepsProvider {
+    minIndex: number;
+    maxIndex: number;
+    indexToValue: (index: number) => number;
+    valueToIndex: (value: number) => number;
+}
+export declare function createStepsProvider(info: StepsInfo): nullish | StepsProvider;
+/**
+ * Snaps thumb values to the closest step values based on the provided steps provider.
+ *
+ * TODO: integrate a resolution parameter to control how many steps to consider.
+ *  The resolution would depend on the size of the slider and the min/max range,
+ *  as well as the displayMin and displayMax.
+ */
+export declare function offsetValues(stepsProvider: nullish | StepsProvider, entries: ReadonlyMap<UUID, number>, offset: number): Map<UUID, number>;
+/**
+ * Snaps a single entry to the closest available step, avoiding conflicts with other entries.
+ */
+export declare function offsetValue(stepsProvider: nullish | StepsProvider, entries: ReadonlyMap<UUID, number>, entry: UUID, offset: number, allowValuesOverlap: boolean): number;
+type Configuration = {
+    stepsProvider: nullish | StepsProvider;
+    resolution: number;
+    min: number;
+    max: number;
+    allowValuesOverlap: boolean;
+};
+/**
+ * Offsets all entries in the given direction, respecting the steps defined in the configuration.
+ */
+export declare function offsetEntriesInDirection(configuration: Configuration, entries: ReadonlyMap<UUID, number>, direction: number): {
+    changed: boolean;
+    entries: ReadonlyMap<UUID, number>;
+};
+/**
+ * Offsets an entry in the given direction, respecting the steps defined in the configuration.
+ */
+export declare function offsetEntryInDirection(configuration: Configuration, entries: ReadonlyMap<UUID, number>, entry: UUID, direction: number): number;
+/**
+ * Offsets all entries to the minimum or maximum value, depending on the direction.
+ */
+export declare function offsetEntryToEnds(configuration: Configuration, entries: ReadonlyMap<UUID, number>, entry: UUID, direction: number): number;
+/**
+ * Offsets all entries to the minimum or maximum value, depending on the direction.
+ */
+export declare function offsetEntriesToEnds(configuration: Configuration, entries: ReadonlyMap<UUID, number>, direction: number): ReadonlyMap<UUID, number>;
+export {};

package/dist/components/arcgis-slider-input/customElement.d.ts

@@ -0,0 +1,60 @@
+/// <reference path="../../index.d.ts" />
+import { PublicLitElement as LitElement, TargetedEvent, JsxNode } from '@arcgis/lumina';
+
+/** [Read more...](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-slider-input/) */
+export declare class ArcgisSliderInput extends LitElement {
+    /**
+     * If true, prevents interaction with the component.
+     *
+     * @default false
+     */
+    disabled: boolean;
+    /** Label for the component. */
+    label?: string;
+    /**
+     * Handle LTR and RTL label placement.
+     *
+     * @default false
+     */
+    flipLabels: boolean;
+    /**
+     * Min value for the component.
+     *
+     * @default 0
+     */
+    min: number;
+    /**
+     * Max value for the component.
+     *
+     * @default 100
+     */
+    max: number;
+    /**
+     * Initial value for the component.
+     *
+     * @default 50
+     */
+    value: number;
+    /**
+     * Increment interval for the component.
+     *
+     * @default 1
+     */
+    step: number;
+    /** If provided, specifies units for the input. */
+    unitsLabel?: string;
+    /**
+     * If true, adds up/down arrows to the input.
+     *
+     * @default false
+     */
+    withSteppers: boolean;
+    /** @deprecated use arcgisValueChange instead. */
+    readonly arcgisSliderInputValueChange: TargetedEvent<this, number>;
+    /** Emitted when the value has changed. */
+    readonly arcgisValueChange: TargetedEvent<this, number>;
+    "@eventTypes": {
+        "arcgisSliderInputValueChange": ArcgisSliderInput["arcgisSliderInputValueChange"]["detail"];
+        "arcgisValueChange": ArcgisSliderInput["arcgisValueChange"]["detail"];
+    };
+}

package/dist/components/arcgis-slider-input/customElement.js

@@ -0,0 +1,31 @@
+import { c as d } from "../../chunks/runtime.js";
+import { css as h, html as m } from "lit";
+import { LitElement as o, createEvent as c } from "@arcgis/lumina";
+import { debounce as b } from "@arcgis/toolkit/function";
+/*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
+See https://js.arcgis.com/5.0/esri/copyright.txt for details.
+v5.0.0-next.113 */
+const g = h`.container{display:flex;align-items:center;justify-content:space-between;position:relative}.slider{width:50%}.input{width:45%}`;
+class $ extends o {
+  constructor() {
+    super(...arguments), this.debouncedApplyValueOnChange = b((e) => this.applyValueOnChange(e), 800), this.disabled = !1, this.flipLabels = !1, this.min = 0, this.max = 100, this.value = 50, this.step = 1, this.withSteppers = !1, this.arcgisSliderInputValueChange = c(), this.arcgisValueChange = c();
+  }
+  static {
+    this.properties = { disabled: 5, label: 1, flipLabels: 5, min: 9, max: 9, value: 9, step: 9, unitsLabel: 1, withSteppers: 5 };
+  }
+  static {
+    this.styles = g;
+  }
+  applyValueOnChange(e) {
+    const { min: i, max: a, value: n } = this, s = Number(e.value), t = i !== void 0 && a !== void 0 ? Math.min(a, Math.max(i, s)) : s;
+    s !== n && (e.value = `${t}`, this.arcgisValueChange.emit(t), this.arcgisSliderInputValueChange.emit(t), this.value = t);
+  }
+  render() {
+    const { disabled: e, min: i, max: a, value: n, step: s, withSteppers: t, flipLabels: r, unitsLabel: p, label: u } = this;
+    return m`<div class="container"><calcite-slider class="slider" .disabled=${e} .min=${i} .max=${a} .value=${n} .step=${s} @calciteSliderInput=${(l) => this.debouncedApplyValueOnChange(l.currentTarget)}></calcite-slider><calcite-input class="input" .disabled=${e} .min=${i} .max=${a} .numberButtonType=${t ? "vertical" : "none"} .prefixText=${r ? p : ""} @calciteInputInput=${(l) => this.debouncedApplyValueOnChange(l.target)} @click=${(l) => l.stopPropagation()} scale=s step=any .suffixText=${r ? "" : p} type=number .value=${`${n}`} .label=${u}></calcite-input></div>`;
+  }
+}
+d("arcgis-slider-input", $);
+export {
+  $ as ArcgisSliderInput
+};

package/dist/components/arcgis-slider-input/index.d.ts

@@ -0,0 +1,3 @@
+import "@esri/calcite-components/components/calcite-slider";
+import "@esri/calcite-components/components/calcite-input";
+export * from "./customElement.js";

package/dist/components/arcgis-slider-input/index.js

@@ -0,0 +1,3 @@
+import "@esri/calcite-components/components/calcite-slider";
+import "@esri/calcite-components/components/calcite-input";
+export * from "./customElement.js";

package/dist/components/arcgis-ticks/css.d.ts

@@ -0,0 +1,11 @@
+export declare const css: {
+    readonly container: "container";
+    readonly ticksContainer: "ticks-container";
+    readonly labelsContainer: "labels-container";
+    readonly tick: "tick";
+    readonly tickMin: "tick--min";
+    readonly tickMax: "tick--max";
+    readonly tickLabel: "tick-label";
+    readonly baseline: "baseline";
+};
+export type CSSClass = (typeof css)[keyof typeof css];

package/dist/components/arcgis-ticks/customElement.d.ts

@@ -0,0 +1,97 @@
+/// <reference path="../../index.d.ts" />
+import { JsxNode, PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+
+type Layout = "horizontal" | "vertical";
+type TickMode = "count" | "percent" | "value";
+type TickValues = number[] | number;
+/** [Read more...](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/) */
+export declare class ArcgisTicks extends LitElement {
+    /**
+     * When `true`, the component will allow clicking on ticks.
+     *
+     * @default false
+     */
+    interactive: boolean;
+    /**
+     * The exponent used to interpolate the position of ticks along the component.
+     * A value of `0` indicates linear interpolation. Positive values indicate exponential interpolation, and negative values indicate logarithmic interpolation.
+     *
+     * Set this property when the range of values is large and users need precision in the lower range of values (for an exponential interpolation), or in the higher range (for a logarithmic interpolation).
+     *
+     * ```tsx
+     * <arcgis-ticks interpolation-exponent={14} min={1} max={5518000} mode="value" values={[1, 11500, 5518000]} />
+     * ```
+     *
+     * @default 0
+     */
+    interpolationExponent: number;
+    /** A function used to format each tick's label. */
+    labelFormatter?: (value: number, defaultFormatter: (value: number) => string) => nullish | string;
+    /**
+     * Determines whether the labels are placed before or after the ticks.
+     *
+     * @default "trailing"
+     */
+    labelPlacement: "leading" | "trailing";
+    /**
+     * Determines the layout/orientation of the component.
+     *
+     * @default "horizontal"
+     */
+    layout: Layout;
+    /**
+     * The component's maximum rendered value.
+     *
+     * @default 100
+     */
+    max: number;
+    /**
+     * The component's minimum rendered value.
+     *
+     * @default 0
+     */
+    min: number;
+    /**
+     * When `true`, the values are displayed from high to low.
+     *
+     * @default false
+     */
+    mirrored: boolean;
+    /**
+     * The mode or method of positioning ticks along the component. It drives how [values](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/#values) is interpreted.
+     * - `count`: Places a fixed number of ticks (provided in the [values](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/#values) property) at equal distances from each other.
+     * - `percent`: [values](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/#values) is interpreted as percentage. If [values](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/#values) is a number, it indicates the interval between ticks. If it is an array, it indicates the percentage values at which to place the ticks.
+     * - `value`: Indicates that ticks will only be placed at the values specified in the property.
+     *
+     * @default "count"
+     * @see [values](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/#values)
+     */
+    mode: TickMode;
+    /**
+     * Indicates whether to render labels for the ticks.
+     *
+     * @default false
+     */
+    showLabels: boolean;
+    /**
+     * Indicates whether to render a line connecting the ticks.
+     *
+     * @default false
+     */
+    showBaseline: boolean;
+    /**
+     * Indicates where ticks will be rendered along the component.
+     * See the description for [mode](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/#mode) for more information about how this property is interpreted by each mode.
+     *
+     * @see [mode](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-ticks/#mode)
+     */
+    values: TickValues;
+    /** Fires when the user clicks on one of the ticks. */
+    readonly arcgisTickClick: TargetedEvent<this, {
+        value: number;
+    }>;
+    "@eventTypes": {
+        "arcgisTickClick": ArcgisTicks["arcgisTickClick"]["detail"];
+    };
+}
+export {};

package/dist/components/arcgis-ticks/customElement.js

@@ -0,0 +1,143 @@
+import { c as $ } from "../../chunks/runtime.js";
+import { css as M, html as c } from "lit";
+import { LitElement as _, createEvent as C, safeClassMap as h, safeStyleMap as d, nothing as y } from "@arcgis/lumina";
+import { formatNumber as A } from "@arcgis/core/intl.js";
+/*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
+See https://js.arcgis.com/5.0/esri/copyright.txt for details.
+v5.0.0-next.113 */
+const l = {
+  container: "container",
+  ticksContainer: "ticks-container",
+  labelsContainer: "labels-container",
+  tick: "tick",
+  tickMin: "tick--min",
+  tickMax: "tick--max",
+  tickLabel: "tick-label",
+  baseline: "baseline"
+}, F = M`:host{display:flex;--arcgis-ticks-tick-length: .5rem;--arcgis-ticks-tick-color: var(--calcite-color-border-input);--arcgis-ticks-gap: 1em}.container{align-items:stretch;display:flex;color:var(--calcite-color-text-2);flex:1;font-weight:var(--calcite-font-weight-medium);font-size:var(--calcite-font-size--2);line-height:1em;position:relative;user-select:none;word-wrap:normal;word-break:normal}.baseline{background-color:var(--arcgis-ticks-tick-color, var(--calcite-color-border-input))}.tick{position:absolute;background-color:var(--arcgis-ticks-tick-color, var(--calcite-color-border-input))}.tick-label{position:absolute}:host([layout="horizontal"]){.ticks-container{height:var(--arcgis-ticks-tick-length)}.labels-container{height:var(--labels-container-height, "auto")}.tick{width:.125rem;height:var(--arcgis-ticks-tick-length);transform:translate(-50%)}.tick-label{transform:translate(-50%)}.tick--min{transform:unset}.tick--max{transform:translate(-100%)}}:host([layout="vertical"]){.ticks-container{width:var(--arcgis-ticks-tick-length)}.labels-container{width:var(--labels-container-width)}.tick{width:var(--arcgis-ticks-tick-length);height:.125rem;transform:translateY(50%)}.tick-label{text-align:right;transform:translateY(50%);text-align:center;width:var(--labels-container-width, "auto")}.tick--min{transform:unset}.tick--max{transform:translateY(100%)}}:host([layout="horizontal"][mirrored]){.tick,.tick-label{transform:translate(50%)}.tick--min{transform:unset}.tick--max{transform:translate(100%)}}:host([layout="vertical"][mirrored]){.tick,.tick-label{transform:translateY(-50%)}.tick--min{transform:unset}.tick--max{transform:translateY(-100%)}}:host([layout="horizontal"][label-placement="leading"]){.container{flex-direction:column;justify-content:flex-end}.labels-container{margin-bottom:var(--arcgis-ticks-gap)}}:host([layout="horizontal"][label-placement="trailing"]){.container{flex-direction:column-reverse;justify-content:flex-end}.labels-container{margin-top:var(--arcgis-ticks-gap)}}:host([layout="vertical"][label-placement="leading"]){.container{flex-direction:row;justify-content:flex-end}:dir(ltr){.labels-container{margin-right:var(--arcgis-ticks-gap)}.tick-label{text-align:right}}:dir(rtl){.labels-container{margin-left:var(--arcgis-ticks-gap)}.tick-label{text-align:left;unicode-bidi:plaintext}}}:host([layout="vertical"][label-placement="trailing"]){.container{flex-direction:row-reverse;justify-content:flex-end}:dir(ltr){.labels-container{margin-left:var(--arcgis-ticks-gap)}.tick-label{text-align:left}}:dir(rtl){.labels-container{margin-right:var(--arcgis-ticks-gap)}.tick-label{text-align:right;unicode-bidi:plaintext}}}:host([interactive]){pointer-events:none;.tick,.tick-label{pointer-events:auto;cursor:pointer}.tick-label:hover{text-decoration:underline}}`;
+class z extends _ {
+  constructor() {
+    super(...arguments), this._formatValue = (e) => A(e, this._formatOptions), this._formatOptions = {
+      style: "decimal",
+      useGrouping: !0,
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    }, this.interactive = !1, this.interpolationExponent = 0, this.labelPlacement = "trailing", this.layout = "horizontal", this.max = 100, this.min = 0, this.mirrored = !1, this.mode = "count", this.showLabels = !1, this.showBaseline = !1, this.values = [], this.arcgisTickClick = C({ cancelable: !1 });
+  }
+  static {
+    this.properties = { _formatOptions: 16, interactive: 7, interpolationExponent: 9, labelFormatter: 0, labelPlacement: 3, layout: 3, max: 9, min: 9, mirrored: 7, mode: 1, showLabels: 5, showBaseline: 5, values: [9, { converter: {
+      fromAttribute(e) {
+        if (e.includes(","))
+          return e.split(",").filter((t) => t.trim() !== "").map(parseFloat).filter((t) => Number.isFinite(t));
+        {
+          const t = parseFloat(e);
+          return Number.isFinite(t) ? [t] : [];
+        }
+      }
+    } }] };
+  }
+  static {
+    this.styles = F;
+  }
+  updated() {
+    const e = this.renderRoot.querySelector(`.${l.labelsContainer}`);
+    if (e) {
+      let t = 0, i = 0;
+      for (const r of this.renderRoot.querySelectorAll(`.${l.tickLabel}`)) {
+        const a = r.getBoundingClientRect();
+        t = Math.max(t, a.width), i = Math.max(i, a.height);
+      }
+      t = Math.ceil(t), i = Math.ceil(i), !t || !i ? (e.style.removeProperty("--labels-container-width"), e.style.removeProperty("--labels-container-height")) : (e.style.setProperty("--labels-container-width", `${t}px`), e.style.setProperty("--labels-container-height", `${i}px`));
+    }
+  }
+  _handleClick(e) {
+    if (!this.interactive)
+      return;
+    const i = e.target.dataset.value;
+    i && this.arcgisTickClick.emit({ value: Number(i) });
+  }
+  _internalLabelFormatter(e) {
+    const t = this.labelFormatter;
+    if (!t)
+      return this._formatValue(e);
+    const i = t(e, this._formatValue);
+    return i ?? this._formatValue(e);
+  }
+  render() {
+    return c`<div class=${h(l.container)} touch-action=none @click=${this._handleClick}>${this._renderContent()}${this._renderBaseline()}</div>`;
+  }
+  _renderContent() {
+    const { interpolationExponent: e, max: t, min: i, mode: r, values: a, layout: o, mirrored: s, showLabels: x } = this, k = [], b = [];
+    for (const [f, u] of L(r, i, t, e, a)) {
+      const p = { [o === "horizontal" ? s ? "right" : "left" : s ? "top" : "bottom"]: `${f}%` }, w = {
+        [l.tick]: !0,
+        [l.tickMin]: f === 0,
+        [l.tickMax]: f === 100
+      };
+      k.push(c`<div class=${h(w)} style=${d(p)} data-value=${u ?? y}></div>`), x && b.push(c`<div class=${h(l.tickLabel)} style=${d(p)} data-value=${u ?? y}>${this._internalLabelFormatter(u)}</div>`);
+    }
+    return [c`<div class=${h(l.labelsContainer)}>${b}</div>`, c`<div class=${h(l.ticksContainer)}>${k}</div>`];
+  }
+  _renderBaseline() {
+    const { showBaseline: e, layout: t } = this;
+    return e && c`<div class=${h(l.baseline)} style=${d({
+      [t === "horizontal" ? "width" : "height"]: "100%",
+      [t === "horizontal" ? "height" : "width"]: "0.125rem"
+    })}></div>` || "";
+  }
+}
+function* L(n, e, t, i, r) {
+  switch (n) {
+    case "value": {
+      const a = Array.isArray(r) ? r : [r];
+      for (const o of a) {
+        const s = P(e, t, o, i) * 100;
+        s >= 0 && s <= 100 && (yield [s, o]);
+      }
+      break;
+    }
+    case "percent": {
+      if (Array.isArray(r))
+        for (const a of r)
+          a >= 0 && a <= 100 && (yield [a, m(e, t, a / 100, i)]);
+      else if (r > 0)
+        for (let a = 0; a <= 100; a += r)
+          yield [a, m(e, t, a / 100, i)];
+      break;
+    }
+    case "count": {
+      const a = Array.isArray(r) ? r[0] : r;
+      if (a <= 1)
+        yield [50, m(e, t, 0.5, i)];
+      else
+        for (let o = 0; o < a; o++) {
+          const s = o * 100 / (a - 1);
+          yield [s, m(e, t, s / 100, i)];
+        }
+      break;
+    }
+  }
+}
+function g(n, e, t) {
+  return t < n ? n : t > e ? e : t;
+}
+function v(n, e, t) {
+  return n + (e - n) * t;
+}
+function P(n, e, t, i = 0) {
+  let r = (t - n) / (e - n);
+  if (r = g(0, 1, r), Math.abs(i) < 1e-9)
+    return r;
+  const a = 1 + Math.expm1(i) * r;
+  return r = Math.log(a) / i, g(0, 1, r);
+}
+function m(n, e, t, i = 0) {
+  if (t = g(0, 1, t), Math.abs(i) < 1e-9)
+    return v(n, e, t);
+  const r = Math.expm1(i * t) / Math.expm1(i);
+  return v(n, e, r);
+}
+$("arcgis-ticks", z);
+export {
+  z as ArcgisTicks
+};

package/dist/components/arcgis-ticks/index.d.ts

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/arcgis-ticks/index.js

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/arcgis-unique-values-list/customElement.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+/// <reference path="../../index.d.ts" />
+import { PublicLitElement as LitElement, TargetedEvent, JsxNode } from '@arcgis/lumina';
+import { SupportedLayer } from './utils';
+
+/**
+ * Displays a list of unique values taking into account field type formatting and field domains.
+ *
+ * [Read more...](https://developers.arcgis.com/javascript/latest/references/common-components/arcgis-unique-values-list/)
+ */
+export declare class ArcgisUniqueValuesList extends LitElement {
+    /** MapView instance, required if uniqueValues is not provided */
+    view?: __esri.MapView | __esri.SceneView;
+    /** Layer instance, required if uniqueValues is not provided, if component needs to format values, or needs to check for field domains. */
+    layer?: SupportedLayer;
+    /** Field name, required if uniqueValues is not provided, if component needs to format values, or needs to check for field domains. */
+    fieldName?: string;
+    /**
+     * List of all unique values. If not provided component will get the unique values from the layer.
+     * An empty list would mean that there are no unique values for this field on the layer. The component renders nothing then.
+     */
+    uniqueValues?: __esri.UniqueValuesResultUniqueValueInfos[];
+    /**
+     * Optional format options if values are numbers.
+     *
+     * e.g.
+     *      {
+     *        style: "decimal",
+     *        useGrouping: true,
+     *        minimumFractionDigits: 0,
+     *        maximumFractionDigits: 2
+     *      }
+     *
+     *      {
+     *        style: "percent",
+     *        useGrouping: true
+     *      }
+     *
+     *      {
+     *        style: "currency",
+     *        currency: "EUR",
+     *        currencyDisplay: "symbol"
+     *      }
+     */
+    numberFormatOptions?: Intl.NumberFormatOptions;
+    /** Lists of selected values */
+    selectedValues?: (number | string)[];
+    /** Sort by default setting */
+    sortBy?: "count" | "name" | "selected";
+    /**
+     * Multiple selections allowed?
+     *
+     * @default false
+     */
+    multiple?: boolean | undefined;
+    /**
+     * Too many values? If true then it displays a message below the list. Only required if uniqueValues is provided.
+     *
+     * @default false
+     */
+    partialUniqueValues?: boolean | undefined;
+    /**
+     * If true, displays the filter option based on the number of fields.
+     *
+     * @default 10
+     */
+    showFilterLength: number;
+    /** Optional, max height of list in pixel. */
+    maxHeight?: number;
+    /** Sets focus on component */
+    setFocus(): Promise<void>;
+    /**
+     * Get all unique values.
+     * E.g. to be used to limit how often these unique values need to be requested from the layer.
+     */
+    getUniqueValues(): Promise<{
+        uniqueValues: __esri.UniqueValuesResultUniqueValueInfos[];
+        partialUniqueValues: boolean;
+    } | undefined>;
+    /** Emitted if selection has changed */
+    readonly arcgisChange: TargetedEvent<this, (string | number)[]>;
+    /** Emitted if the sort order has changed */
+    readonly arcgisSortByChange: TargetedEvent<this, string | undefined>;
+    /** Emitted once the component is loaded. Useful when no uniqueValues were passed in. */
+    readonly arcgisLoad: TargetedEvent<this, void>;
+    "@eventTypes": {
+        "arcgisChange": ArcgisUniqueValuesList["arcgisChange"]["detail"];
+        "arcgisLoad": ArcgisUniqueValuesList["arcgisLoad"]["detail"];
+        "arcgisSortByChange": ArcgisUniqueValuesList["arcgisSortByChange"]["detail"];
+    };
+}