@geoscene/common-components 5.0.19

package/dist/components/geoscene-ckeditor5/index.d.ts

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

package/dist/components/geoscene-ckeditor5/index.js

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

package/dist/components/geoscene-ckeditor5/types.d.ts

@@ -0,0 +1,15 @@
+/** @internal */
+export type InputMentionField = {
+  id: string;
+  name: string;
+};
+
+/** @internal */
+export type DisplayMentionField = InputMentionField
+  & {
+  isFirstExpression: boolean;
+  isFirstField: boolean;
+};
+
+/** @internal */
+export type EditorType = "html" | "markdown";

package/dist/components/geoscene-ckeditor5-popover/customElement.d.ts

@@ -0,0 +1,40 @@
+/// <reference path="../../index.d.ts" />
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+
+/** @internal */
+export abstract class GeosceneCkeditor5Popover extends LitElement {
+  /** Guid for ckeditor popover instance. */
+  accessor guid: `${string}-${string}-${string}-${string}-${string}`;
+  /**
+   * Cancel button text.
+   *
+   * @default "Cancel"
+   */
+  accessor intlCancel: string;
+  /** Popover label text. */
+  accessor intlLabel: string | undefined;
+  /**
+   * Ok button text.
+   *
+   * @default "Ok"
+   */
+  accessor intlOk: string;
+  /** Reference element for the popover. */
+  accessor refElement: HTMLElement | undefined;
+  /** Reposition the component. */
+  reposition(): Promise<void>;
+  /** @deprecated use geoscenePopoverClosed instead */
+  readonly geosceneCkeditor5PopoverClosed: import("@geoscene/lumina").TargetedEvent<this, {
+      guid: string;
+      data?: string;
+  }>;
+  /** Emitted when the popover has been closed. */
+  readonly geoscenePopoverClosed: import("@geoscene/lumina").TargetedEvent<this, {
+      guid: string;
+      data?: string;
+  }>;
+  readonly "@eventTypes": {
+    geosceneCkeditor5PopoverClosed: GeosceneCkeditor5Popover["geosceneCkeditor5PopoverClosed"]["detail"];
+    geoscenePopoverClosed: GeosceneCkeditor5Popover["geoscenePopoverClosed"]["detail"];
+  };
+}

package/dist/components/geoscene-ckeditor5-popover/customElement.js

@@ -0,0 +1,58 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { c as a } from "../../chunks/runtime.js";
+import { css as l, html as n } from "lit";
+import { LitElement as d, createEvent as o, safeClassMap as e, nothing as c } from "@geoscene/lumina";
+import { createRef as s, ref as r } from "lit/directives/ref.js";
+import { Task as p } from "@lit/task";
+import { unsafeGetElementDirection as h } from "@geoscene/toolkit/dom";
+import { generateGuid as g } from "@geoscene/toolkit/string";
+import { i as u } from "../../chunks/commonFunctions.js";
+import { C as i } from "../../chunks/resources.js";
+const m = l`.geoscene-app-ckeditor-popover-footer{display:flex;justify-content:flex-end;margin-top:var(--calcite-space-sm);padding:0 var(--calcite-space-lg)}.geoscene-app-ckeditor-popover-container{margin:0 var(--calcite-space-md) 0 0;padding-bottom:var(--calcite-space-lg);box-shadow:val(--calcite-shadow-1)}`;
+class f extends d {
+  constructor() {
+    super(), this.okButton = s(), this.popoverNode = s(), this._propWatcherTask = new p(this, {
+      task: async ([t]) => {
+        if (!u(t)) {
+          console.error("[ckeditor5] Required properties are missing.");
+          return;
+        }
+      },
+      args: () => [this.refElement]
+    }), this.guid = g(), this.intlOk = "Ok", this.intlCancel = "Cancel", this.geosceneCkeditor5PopoverClosed = o(), this.geoscenePopoverClosed = o(), this.listen("geosceneCreated", this.afterEditorCreated), this.listen("geosceneSourceEditingChanged", this.onSourceEditingStatusChanged);
+  }
+  static {
+    this.properties = { guid: 1, refElement: 0, intlOk: 1, intlCancel: 1, intlLabel: 1 };
+  }
+  static {
+    this.styles = m;
+  }
+  async reposition() {
+    this.popoverNode.value?.reposition();
+  }
+  afterEditorCreated(t) {
+    this.editor = t.target, this.reposition(), this.requestUpdate();
+  }
+  onSourceEditingStatusChanged(t) {
+    this.okButton.value && (this.okButton.value.disabled = t.detail);
+  }
+  render() {
+    return this.el.classList.add("js-app-flyout"), this._propWatcherTask.render({
+      complete: () => n`<calcite-popover class=${e(i.popover)} dir=${h(this.el) ?? c} placement=leading-start open pointer-disabled .referenceElement=${this.refElement} .offsetDistance=${-Math.round(this.refElement.getBoundingClientRect().width)} offset-skidding=50 .label=${this.intlLabel ?? ""} focus-trap-disabled trigger-disabled top-layer-disabled ${r(this.popoverNode)}><div class=${e(i.geosceneAppCkeditorPopoverContainer)}><slot></slot><div class=${e(i.geosceneAppCkeditorPopoverFooter)}><calcite-button .label=${this.intlOk} @click=${async (t) => {
+        this.okButton.value?.disabled || (t.stopPropagation(), this.geosceneCkeditor5PopoverClosed.emit({
+          guid: this.guid,
+          data: await this.editor?.getData()
+        }), this.geoscenePopoverClosed.emit({
+          guid: this.guid,
+          data: await this.editor?.getData()
+        }));
+      }} ${r(this.okButton)}>${this.intlOk}</calcite-button><calcite-button appearance=outline-fill .label=${this.intlCancel} @click=${(t) => {
+        t.stopPropagation(), this.geosceneCkeditor5PopoverClosed.emit({ guid: this.guid }), this.geoscenePopoverClosed.emit({ guid: this.guid });
+      }}>${this.intlCancel}</calcite-button></div></div></calcite-popover>`
+    });
+  }
+}
+a("geoscene-ckeditor5-popover", f);
+export {
+  f as GeosceneCkeditor5Popover
+};

package/dist/components/geoscene-ckeditor5-popover/index.d.ts

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

package/dist/components/geoscene-ckeditor5-popover/index.js

@@ -0,0 +1,3 @@
+import "@geoscene/calcite-components/components/calcite-popover";
+import "@geoscene/calcite-components/components/calcite-button";
+export * from "./customElement.js";

package/dist/components/geoscene-color-input/customElement.d.ts

@@ -0,0 +1,108 @@
+/// <reference path="../../index.d.ts" />
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { IPopoverProps } from "../../utils/types.js";
+import type { T9nMeta } from "@geoscene/lumina/controllers";
+import type { Popover as Popover } from "@geoscene/calcite-components/components/calcite-popover";
+
+/** @internal */
+export abstract class GeosceneColorInput extends LitElement {
+  /** @internal */
+  protected _messages: Partial<{
+      clearColor: string;
+      commitColor: string;
+      deleteColor: string;
+      noColor: string;
+      recentColors: string;
+      selectColor: string;
+  }> & T9nMeta<{
+      clearColor: string;
+      commitColor: string;
+      deleteColor: string;
+      noColor: string;
+      recentColors: string;
+      selectColor: string;
+  }>;
+  /**
+   * Display option to set no color.
+   *
+   * @default false
+   */
+  accessor clearable: boolean;
+  /** The selected color as a HEX value. If not set it will display a 'transparent' color swatch. */
+  accessor color: string | undefined;
+  /**
+   * Control whether the component should be displayed in a compact style (i.e., fewer recent color options).
+   *
+   * @default false
+   */
+  accessor compact: boolean;
+  /**
+   * Control whether the component is disabled.
+   *
+   * @default false
+   */
+  accessor disabled: boolean;
+  /**
+   * If true, do not display recent colors.
+   *
+   * @default false
+   */
+  accessor hideRecentColors: boolean;
+  /** Replace localized message strings with your own strings. */
+  accessor messageOverrides: {
+      clearColor?: string | undefined;
+      commitColor?: string | undefined;
+      deleteColor?: string | undefined;
+      noColor?: string | undefined;
+      recentColors?: string | undefined;
+      selectColor?: string | undefined;
+  };
+  /**
+   * Determines where the popup color picker will be positioned relative to the color input.
+   *
+   * @default "auto"
+   */
+  accessor placement: Popover["placement"];
+  /** Convenience prop to specify common popover props. */
+  accessor popoverProps: IPopoverProps | undefined;
+  /**
+   * If true, allow transparency to be modified within the color picker.
+   *
+   * @default false
+   */
+  accessor showTransparency: boolean;
+  /**
+   * The id of the local storage element that will store recent colors.
+   *
+   * @default "geoscene-color-input-storage-colors"
+   */
+  accessor storageId: string;
+  /** Close the component. */
+  close(): Promise<void>;
+  /** Set focus on the component. */
+  setFocus(): Promise<void>;
+  /** Emitted when the color has changed. */
+  readonly geosceneChange: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /** @deprecated use geosceneChange instead */
+  readonly geosceneColorInputChange: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /** @deprecated use geoscenePickerClose instead */
+  readonly geosceneColorInputPopoverClose: import("@geoscene/lumina").TargetedEvent<this, string>;
+  /** @deprecated use geoscenePickerOpen instead */
+  readonly geosceneColorInputPopoverOpen: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /** @deprecated use geosceneSwatchUpdate instead */
+  readonly geosceneColorInputSwatchUpdate: import("@geoscene/lumina").TargetedEvent<this, string | undefined>;
+  readonly geoscenePickerClose: import("@geoscene/lumina").TargetedEvent<this, string>;
+  readonly geoscenePickerOpen: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /** Emitted when a color swatch is updated (emits selected color hex). */
+  readonly geosceneSwatchUpdate: import("@geoscene/lumina").TargetedEvent<this, string | undefined>;
+  readonly "@eventTypes": {
+    geosceneChange: GeosceneColorInput["geosceneChange"]["detail"];
+    geosceneColorInputChange: GeosceneColorInput["geosceneColorInputChange"]["detail"];
+    geosceneColorInputPopoverClose: GeosceneColorInput["geosceneColorInputPopoverClose"]["detail"];
+    geosceneColorInputPopoverOpen: GeosceneColorInput["geosceneColorInputPopoverOpen"]["detail"];
+    geosceneColorInputSwatchUpdate: GeosceneColorInput["geosceneColorInputSwatchUpdate"]["detail"];
+    geoscenePickerClose: GeosceneColorInput["geoscenePickerClose"]["detail"];
+    geoscenePickerOpen: GeosceneColorInput["geoscenePickerOpen"]["detail"];
+    geosceneSwatchUpdate: GeosceneColorInput["geosceneSwatchUpdate"]["detail"];
+  };
+}

package/dist/components/geoscene-color-input/customElement.js

@@ -0,0 +1,135 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { c as C } from "../../chunks/runtime.js";
+import { keyed as n } from "lit/directives/keyed.js";
+import { LitElement as m, createEvent as i } from "@geoscene/lumina";
+import { css as u, render as g, html as s, svg as f } from "lit";
+import { createRef as w, ref as a } from "lit/directives/ref.js";
+import { unsafeGetElementDirection as v } from "@geoscene/toolkit/dom";
+import { debounce as E } from "@geoscene/toolkit/function";
+import { u as k } from "../../chunks/useT9n.js";
+function $(l, e, o) {
+  window.localStorage.setItem(l, JSON.stringify(e));
+}
+function y(l, e) {
+  const o = window.localStorage.getItem(l);
+  return o && e ? JSON.parse(o) : o;
+}
+const S = u`:host,geoscene-picker-input{display:block}.color-picker-container{display:flex;flex-direction:column}.color-picker{--calcite-color-border-1: transparent;overflow-x:hidden}.preview-swatch{width:100%;height:24px}.recent-colors-container{align-items:center;border:var(--calcite-border-width-sm) solid var(--calcite-color-border-input);display:flex;gap:var(--calcite-space-sm);height:32px;padding:0 var(--calcite-space-xs);transition:outline-offset .1s ease-in-out,outline-color .1s ease-in-out}.preview-recent-swatch{cursor:pointer}.recent-colors-container:focus,.preview-recent-swatch:focus{outline:var(--calcite-border-width-md) solid var(--calcite-color-brand);outline-offset:var(--calcite-border-width-md)}.empty-swatch{cursor:default}.end-action{display:flex}`;
+class I extends m {
+  constructor() {
+    super(), this._messages = k(), this.actionEl = w(), this.setRecentColorElement = (e) => (o) => {
+      switch (e) {
+        case 1:
+          this.recentColor1El = o;
+          break;
+        case 2:
+          this.recentColor2El = o;
+          break;
+        default:
+          this.recentColor3El = o;
+      }
+    }, this.recentColors = [], this.clearable = !1, this.compact = !1, this.disabled = !1, this.placement = "auto", this.storageId = "geoscene-color-input-storage-colors", this.hideRecentColors = !1, this.showTransparency = !1, this.geosceneChange = i(), this.geosceneColorInputChange = i(), this.geosceneColorInputPopoverClose = i(), this.geosceneColorInputPopoverOpen = i(), this.geosceneColorInputSwatchUpdate = i(), this.geosceneInternalStoredColor = i(), this.geoscenePickerClose = i(), this.geoscenePickerOpen = i(), this.geosceneSwatchUpdate = i(), this.listenOn(document, "geosceneInternalStoredColor", this.handleUpdateRecentColors), this.listenOn(document, "geosceneRecentColorsUpdate", this.handleStoreNewRecentColor);
+  }
+  static {
+    this.properties = { recentColors: 16, clearable: 5, color: 1, compact: 5, disabled: 5, messageOverrides: 0, placement: 1, popoverProps: 0, storageId: 1, hideRecentColors: 5, showTransparency: 5 };
+  }
+  static {
+    this.styles = S;
+  }
+  async close() {
+    await this.inlineInputEl?.close();
+  }
+  async setFocus() {
+    await this.inlineInputEl?.setFocus();
+  }
+  load() {
+    this.setRecentColorsFromStorage();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this.removeTooltip();
+  }
+  async handleOpen() {
+    await this.colorPickerEl?.setFocus(), this.geoscenePickerOpen.emit(), this.geosceneColorInputPopoverOpen.emit();
+  }
+  setInlineInputRef(e) {
+    this.inlineInputEl = e;
+  }
+  setColorPickerRef(e) {
+    e && (this.colorPickerEl = e);
+  }
+  getRecentColorElement(e) {
+    switch (e) {
+      case 1:
+        return this.recentColor1El;
+      case 2:
+        return this.recentColor2El;
+      default:
+        return this.recentColor3El;
+    }
+  }
+  setRecentColorsFromStorage() {
+    const e = y(this.storageId, !0);
+    e && (this.recentColors = [...e]);
+  }
+  handleSwatchClickOrKeyUp(e) {
+    if ("key" in e && e.key !== "Enter" && e.key !== "Space")
+      return;
+    const t = e.currentTarget.color || void 0;
+    this.updateColor(t), this.geosceneSwatchUpdate.emit(t), this.geosceneColorInputSwatchUpdate.emit(t), setTimeout(() => this.recentColor1El?.focus(), 200);
+  }
+  handleRecentColorsKeyDown(e) {
+    if (this.recentColors.length === 1)
+      return;
+    const o = e.key;
+    let t;
+    this.activeColorSwatchEl === this.recentColor1El ? t = 1 : this.activeColorSwatchEl === this.recentColor2El ? t = 2 : this.activeColorSwatchEl === this.recentColor3El && (t = 3), o === "ArrowLeft" && (!t || t === 1 ? this.getRecentColorElement(this.recentColors.length)?.focus() : this.getRecentColorElement(t - 1)?.focus()), o === "ArrowRight" && (!t || t === this.recentColors.length ? this.recentColor1El?.focus() : this.getRecentColorElement(t + 1)?.focus());
+  }
+  handleUpdateActiveSwatch(e) {
+    this.activeColorSwatchEl = e.target;
+  }
+  handleStoreNewRecentColor(e) {
+    this.storeRecentColorToStorage(e.detail);
+  }
+  handleUpdateRecentColors(e) {
+    e.composedPath().includes(this.el) || this.setRecentColorsFromStorage();
+  }
+  handleClearColor() {
+    this.updateColor(void 0);
+  }
+  updateColor(e, o = !0) {
+    e !== this.color && (this.color = e, this.geosceneChange.emit(), this.geosceneColorInputChange.emit(), o && this.storeRecentColorToStorage(e));
+  }
+  storeRecentColorToStorage(e) {
+    if (!e)
+      return;
+    e.length > 7 && (e = e.slice(0, 7));
+    const t = [e, ...this.recentColors.filter((r) => r !== e)].slice(0, 3);
+    $(this.storageId, t), this.recentColors = t, this.geosceneInternalStoredColor.emit();
+  }
+  handleClose(e) {
+    e.stopPropagation(), this.storeRecentColorToStorage(this.colorPickerEl?.value), this.geoscenePickerClose.emit(this.colorPickerEl?.value), this.geosceneColorInputPopoverClose.emit(this.colorPickerEl?.value);
+  }
+  addTooltip(e) {
+    this.removeTooltip(), this.tooltipContainerEl = document.createElement("div"), g(s`<calcite-tooltip .placement=${e.placement ?? "auto"} .referenceElement=${e.referenceElement} overlay-positioning=fixed open>${e.innerHTML}</calcite-tooltip>`, this.tooltipContainerEl), document.body.append(this.tooltipContainerEl);
+  }
+  removeTooltip() {
+    this.tooltipContainerEl?.parentNode && (this.tooltipContainerEl.remove(), this.tooltipContainerEl = void 0);
+  }
+  render() {
+    const { compact: e, disabled: o, recentColors: t, _messages: r } = this, h = [t[0], t[1]], d = v(this.el) === "rtl";
+    return e || h.push(t[2]), s`<geoscene-picker-input .disabled=${o} .intlDone=${r.commitColor} .heading=${r.selectColor} .label=${r.selectColor} @geoscenePopoverOpen=${this.handleOpen} @geoscenePopoverClose=${this.handleClose} .popoverProps=${this.popoverProps} ${a(this.setInlineInputRef)}><div class="color-picker-container" slot=content>${n(`color-picker${e ? "--compact" : ""}`, s`<calcite-color-picker .clearable=${this.clearable} class="color-picker" @calciteColorPickerInput=${E((c) => {
+      c.stopPropagation(), this.updateColor(this.colorPickerEl.value, !1);
+    }, 500)} .scale=${e ? "s" : "m"} .storageId=${this.storageId} .alphaChannel=${this.showTransparency} .value=${this.color} ${a(this.setColorPickerRef)}></calcite-color-picker>`)}</div><div slot=preview><calcite-color-picker-swatch class="preview-swatch" .color=${this.color} scale=s></calcite-color-picker-swatch></div>${!this.hideRecentColors && s`<div slot=content-end class="recent-colors-container" @keydown=${this.handleRecentColorsKeyDown} tabindex=-1>${h.map((c, p) => c ? n(c, s`<calcite-color-picker-swatch class="preview-recent-swatch" role=button scale=s tabindex=0 .active=${c === this.color} .color=${c} @click=${this.handleSwatchClickOrKeyUp} @keyup=${this.handleSwatchClickOrKeyUp} @focus=${this.handleUpdateActiveSwatch} ${a(this.setRecentColorElement(p + 1))}></calcite-color-picker-swatch>`) : this.renderEmptySwatch(`empty-swatch-${p}`))}</div>` || ""}${this.clearable && s`<div slot=content-end class="end-action"><calcite-action icon=circle-disallowed scale=s .label=${r.clearColor} .text=${r.clearColor ?? ""} @click=${this.handleClearColor} @mouseover=${() => this.addTooltip({
+      referenceElement: this.actionEl.value,
+      placement: d ? "right-start" : "left-start",
+      innerHTML: r.noColor ?? ""
+    })} @mouseout=${() => this.removeTooltip()} ${a(this.actionEl)}></calcite-action></div>` || ""}</geoscene-picker-input>`;
+  }
+  renderEmptySwatch(e) {
+    return n(e, s`<svg class="empty-swatch" viewBox="0 0 20 20" xmlns=http://www.w3.org/2000/svg width=20>${f`<rect width=20 height=20 fill=#f8f8f8 stroke=#000 stroke-dasharray=2 />`}</svg>`);
+  }
+}
+C("geoscene-color-input", I);
+export {
+  I as GeosceneColorInput
+};

package/dist/components/geoscene-color-input/index.d.ts

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

package/dist/components/geoscene-color-input/index.js

@@ -0,0 +1,6 @@
+import "@geoscene/calcite-components/components/calcite-tooltip";
+import "../geoscene-picker-input/index.js";
+import "@geoscene/calcite-components/components/calcite-color-picker";
+import "@geoscene/calcite-components/components/calcite-color-picker-swatch";
+import "@geoscene/calcite-components/components/calcite-action";
+export * from "./customElement.js";

package/dist/components/geoscene-field-info/customElement.d.ts

@@ -0,0 +1,207 @@
+/// <reference path="../../index.d.ts" />
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { FieldInfoLayer } from "./utils/basic.js";
+import type { T9nMeta } from "@geoscene/lumina/controllers";
+
+/** @internal */
+export abstract class GeosceneFieldInfo extends LitElement {
+  /** @internal */
+  protected _messages: {
+      fieldType: string;
+      fieldAlias: string;
+      fieldDescription: string;
+      fieldValueType: string;
+      fieldSampleValue: string;
+      fieldDecimalPlaces: string;
+      fieldMinimumFractionDigits: string;
+      fieldMaximumFractionDigits: string;
+      fieldStatistics: string;
+      fieldDescriptionNotSet: string;
+      fieldValueTypeNotSet: string;
+      fieldSampleRetrieving: string;
+      fieldSampleNotAvailable: string;
+      fieldDecimalPlacesNotAvailable: string;
+      fieldNumDecimalPlaces: string;
+      fieldStatisticsRetrieving: string;
+      fieldStatisticsNotAvailable: string;
+      fieldUniqueValuesRetrieving: string;
+      fieldUniqueValuesNotAvailable: string;
+      fieldTypes: {
+          integer: string;
+          smallInteger: string;
+          bigInteger: string;
+          single: string;
+          double: string;
+          long: string;
+          string: string;
+          date: string;
+          dateOnly: string;
+          timeOnly: string;
+          timestampOffset: string;
+          oid: string;
+          guid: string;
+          globalId: string;
+      };
+      fieldValueTypes: {
+          nameOrTitle: string;
+          description: string;
+          typeOrCategory: string;
+          countOrAmount: string;
+          percentageOrRatio: string;
+          measurement: string;
+          uniqueIdentifier: string;
+          orderedOrRanked: string;
+          binary: string;
+          locationOrPlaceName: string;
+          coordinate: string;
+          currency: string;
+          phoneNumber: string;
+          emailAddress: string;
+          dateAndTime: string;
+      };
+      statistics: {
+          numberOfValues: string;
+          numberOfNulls: string;
+          allNulls: string;
+          topValues: string;
+          topTenValues: string;
+          count: string;
+          sumOfValues: string;
+          minimum: string;
+          maximum: string;
+          average: string;
+          standardDeviation: string;
+          minimumDate: string;
+          maximumDate: string;
+          averageDate: string;
+          minimumTime: string;
+          maximumTime: string;
+          averageTime: string;
+          timespan: string;
+          timeSpanOptions: {
+              day: string;
+              days: string;
+              month: string;
+              months: string;
+              year: string;
+              years: string;
+          };
+      };
+  } & T9nMeta<{
+      fieldType: string;
+      fieldAlias: string;
+      fieldDescription: string;
+      fieldValueType: string;
+      fieldSampleValue: string;
+      fieldDecimalPlaces: string;
+      fieldMinimumFractionDigits: string;
+      fieldMaximumFractionDigits: string;
+      fieldStatistics: string;
+      fieldDescriptionNotSet: string;
+      fieldValueTypeNotSet: string;
+      fieldSampleRetrieving: string;
+      fieldSampleNotAvailable: string;
+      fieldDecimalPlacesNotAvailable: string;
+      fieldNumDecimalPlaces: string;
+      fieldStatisticsRetrieving: string;
+      fieldStatisticsNotAvailable: string;
+      fieldUniqueValuesRetrieving: string;
+      fieldUniqueValuesNotAvailable: string;
+      fieldTypes: {
+          integer: string;
+          smallInteger: string;
+          bigInteger: string;
+          single: string;
+          double: string;
+          long: string;
+          string: string;
+          date: string;
+          dateOnly: string;
+          timeOnly: string;
+          timestampOffset: string;
+          oid: string;
+          guid: string;
+          globalId: string;
+      };
+      fieldValueTypes: {
+          nameOrTitle: string;
+          description: string;
+          typeOrCategory: string;
+          countOrAmount: string;
+          percentageOrRatio: string;
+          measurement: string;
+          uniqueIdentifier: string;
+          orderedOrRanked: string;
+          binary: string;
+          locationOrPlaceName: string;
+          coordinate: string;
+          currency: string;
+          phoneNumber: string;
+          emailAddress: string;
+          dateAndTime: string;
+      };
+      statistics: {
+          numberOfValues: string;
+          numberOfNulls: string;
+          allNulls: string;
+          topValues: string;
+          topTenValues: string;
+          count: string;
+          sumOfValues: string;
+          minimum: string;
+          maximum: string;
+          average: string;
+          standardDeviation: string;
+          minimumDate: string;
+          maximumDate: string;
+          averageDate: string;
+          minimumTime: string;
+          maximumTime: string;
+          averageTime: string;
+          timespan: string;
+          timeSpanOptions: {
+              day: string;
+              days: string;
+              month: string;
+              months: string;
+              year: string;
+              years: string;
+          };
+      };
+  }>;
+  /** Required field name. */
+  accessor fieldName: string | undefined;
+  /**
+   * If true, hide the field alias section.
+   *
+   * @default false
+   */
+  accessor hideAlias: boolean;
+  /**
+   * If true, hide the decimal places section.
+   *
+   * @default false
+   */
+  accessor hideNumericFormat: boolean;
+  /**
+   * If true, hide statistics (i.e., no top 10 values for string and no stats for number and date fields).
+   *
+   * @default false
+   */
+  accessor hideStatistics: boolean;
+  /** Required layer instance. */
+  accessor layer: FieldInfoLayer | undefined;
+  /** View instance. If no view is provided all dates will show in 'system' timezone. */
+  accessor view: __geoscene.View | undefined;
+  /** Refresh the field info display after external changes are made. */
+  refresh(): Promise<void>;
+  /** Emitted once all information is displayed. */
+  readonly geosceneComplete: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /** @deprecated use geosceneComplete instead. */
+  readonly geosceneFieldInfoComplete: import("@geoscene/lumina").TargetedEvent<this, void>;
+  readonly "@eventTypes": {
+    geosceneComplete: GeosceneFieldInfo["geosceneComplete"]["detail"];
+    geosceneFieldInfoComplete: GeosceneFieldInfo["geosceneFieldInfoComplete"]["detail"];
+  };
+}