@geoscene/map-components 4.33.18

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

@@ -0,0 +1,6 @@
+import "@esri/calcite-components/components/calcite-label";
+import "@esri/calcite-components/components/calcite-slider";
+import "@esri/calcite-components/components/calcite-button";
+import "@esri/calcite-components/components/calcite-checkbox";
+import "@esri/calcite-components/components/calcite-icon";
+export * from "./customElement.js";

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

@@ -0,0 +1,6 @@
+import "@esri/calcite-components/components/calcite-label";
+import "@esri/calcite-components/components/calcite-slider";
+import "@esri/calcite-components/components/calcite-button";
+import "@esri/calcite-components/components/calcite-checkbox";
+import "@esri/calcite-components/components/calcite-icon";
+export * from "./customElement.js";

package/dist/components/geoscene-zoom/css.d.ts

@@ -0,0 +1,7 @@
+export declare const css: {
+    readonly base: "geoscene-zoom";
+    readonly horizontalLayout: "geoscene-zoom--horizontal";
+    readonly button: "geoscene-widget--button";
+    readonly zoomIn: "geoscene-zoom__zoom-in";
+    readonly zoomOut: "geoscene-zoom__zoom-out";
+};

package/dist/components/geoscene-zoom/customElement.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { default as MapView } from '@geoscene/core/views/MapView.js';
+import { default as SceneView } from '@geoscene/core/views/SceneView.js';
+import { JsxNode, PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+
+type Layout = "horizontal" | "vertical";
+type State = "disabled" | "ready";
+/**
+ * The Zoom component allows users to zoom in/out within a map or scene.
+ *
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-zoom/)
+ */
+export declare class GeosceneZoom extends LitElement {
+    /**
+     * If true, the component will not be destroyed automatically when it is
+     * disconnected from the document. This is useful when you want to move the
+     * component to a different place on the page, or temporarily hide it. If this
+     * is set, make sure to call the [destroy](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-zoom/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
+     */
+    autoDestroyDisabled: boolean;
+    /**
+     * Icon which represents the component.
+     * Typically used when the component is controlled by another component (e.g. by the Expand component).
+     *
+     * @see [Calcite Icons](https://doc.geoscene.cn/calcite-design-system/icons/)
+     * @default "magnifying-glass-plus"
+     */
+    icon?: string;
+    /** The component's default label. */
+    label?: string;
+    /**
+     * Determines the layout/orientation of the Zoom widget.
+     *
+     * @default "vertical"
+     */
+    layout: Layout;
+    /**
+     * Replace localized message strings with your own strings.
+     *
+     * _**Note**: Individual message keys may change between releases._
+     */
+    messageOverrides?: typeof this.messages._overrides;
+    /** @default "top-left" */
+    position: __geoscene.UIPosition;
+    /**
+     * By assigning the `id` attribute of the Map or Scene component to this property, you can position a child component anywhere in the DOM while still maintaining a connection to the Map or Scene.
+     *
+     * @see [Associate components with a Map or Scene component](https://doc.geoscene.cn/javascript/4.33/programming-patterns/#associate-components-with-a-map-or-scene-component)
+     */
+    referenceElement?: GeosceneReferenceElement | string;
+    /**
+     * The current state of the component.
+     *
+     * @default "disabled"
+     */
+    state: State;
+    /** Permanently destroy the component. */
+    destroy(): Promise<void>;
+    /** Zooms the view in by an LOD factor of 0.5. */
+    zoomIn(): Promise<void>;
+    /** Zooms the view out by an LOD factor of 2. */
+    zoomOut(): Promise<void>;
+    /** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
+    readonly geoscenePropertyChange: TargetedEvent<this, {
+        name: "state";
+    }>;
+    /** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
+    readonly geosceneReady: TargetedEvent<this, void>;
+    private messages: Partial<{
+        componentLabel: string;
+        zoomIn: string;
+        zoomOut: string;
+    }> & import('@arcgis/lumina/controllers').T9nMeta<{
+        componentLabel: string;
+        zoomIn: string;
+        zoomOut: string;
+    }>;
+}
+export {};

package/dist/components/geoscene-zoom/customElement.js

@@ -0,0 +1,86 @@
+import { c as h } from "../../chunks/runtime.js";
+import { html as f } from "lit-html";
+import { classes as i } from "@arcgis/components-utils";
+import { ignoreAbortErrors as l } from "@geoscene/core/core/promiseUtils.js";
+import { when as m } from "@geoscene/core/core/reactiveUtils.js";
+import { LitElement as y, createEvent as p, noShadowRoot as g, safeClassMap as r, nothing as u } from "@arcgis/lumina";
+import { usePropertyChange as z } from "@arcgis/lumina/controllers";
+import { u as b } from "../../chunks/useT9n.js";
+import { u as O } from "../../chunks/useView.js";
+import { css as Z } from "@lit/reactive-element/css-tag.js";
+/*! All material copyright GeoScene, All Rights Reserved, unless otherwise specified.
+See https://js.geoscene.cn/4.33/geoscene/copyright.txt for details.
+v4.33.18 */
+const a = {
+  base: "geoscene-zoom",
+  horizontalLayout: "geoscene-zoom--horizontal",
+  button: "geoscene-widget--button",
+  zoomIn: "geoscene-zoom__zoom-in",
+  zoomOut: "geoscene-zoom__zoom-out"
+};
+function I(t) {
+  if (t.type === "3d")
+    return !!t.ready;
+  if (!t?.ready)
+    return !1;
+  const e = d(t), s = t.constraints?.effectiveMaxScale;
+  return s === 0 || e > s;
+}
+function w(t) {
+  if (t.type === "3d")
+    return !!t.ready;
+  if (!t?.ready)
+    return !1;
+  const e = d(t), s = t.constraints?.effectiveMinScale;
+  return s === 0 || e < s;
+}
+function d(t) {
+  const o = t?.animation?.target;
+  return (o && "then" in o ? void 0 : o?.scale) ?? t?.scale ?? 0;
+}
+const x = Z`@layer{geoscene-zoom,.geoscene-zoom{display:flex;flex-flow:column nowrap;box-shadow:0 1px 2px #0000004d}.geoscene-zoom__zoom-out{border-block-start:solid 1px var(--calcite-color-border-1)}.geoscene-zoom--horizontal{flex-flow:row-reverse nowrap}.geoscene-zoom--horizontal .geoscene-zoom__zoom-out{border-block-start:none;border-inline-end:solid 1px var(--calcite-color-border-1)}}`;
+class $ extends y {
+  constructor() {
+    super(...arguments), this.messages = b({}), this.view = O(this), this.canZoomIn = !1, this.canZoomOut = !1, this.autoDestroyDisabled = !1, this.icon = "magnifying-glass-plus", this.layout = "vertical", this.position = "top-left", this.state = "disabled", this.geoscenePropertyChange = z()("state"), this.geosceneReady = p();
+  }
+  static {
+    this.properties = { canZoomIn: 16, canZoomOut: 16, autoDestroyDisabled: 5, icon: 1, label: 1, layout: 3, messageOverrides: 0, position: 1, referenceElement: 1, state: 3 };
+  }
+  static {
+    this.shadowRootOptions = g;
+  }
+  static {
+    this.styles = x;
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+  async zoomIn() {
+    const { view: o } = this;
+    !this.canZoomIn || !o || (o.type === "2d" ? o.mapViewNavigation.zoomIn() : l(o.goTo({ zoomFactor: 2 })));
+  }
+  async zoomOut() {
+    const { view: o } = this;
+    !this.canZoomOut || !o || (o.type === "2d" ? o.mapViewNavigation.zoomOut() : l(o.goTo({ zoomFactor: 0.5 })));
+  }
+  loaded() {
+    this.manager.onLifecycle(() => [
+      m(() => this.view?.stationary, () => {
+        this.canZoomIn = I(this.view), this.canZoomOut = w(this.view);
+      }, { initial: !0 }),
+      m(() => this.view?.ready ? "ready" : "disabled", (o) => {
+        this.state = o;
+      }, { sync: !0, initial: !0 })
+    ]);
+  }
+  render() {
+    const o = {
+      [a.horizontalLayout]: this.layout === "horizontal"
+    }, { canZoomIn: e, canZoomOut: s } = this, { zoomIn: n, zoomOut: c } = this.messages;
+    return f`<div class=${r(i(a.base, o))}><calcite-button class=${r(i(a.button, a.zoomIn))} .disabled=${!e} icon-start=plus kind=neutral .label=${n} @click=${this.zoomIn} title=${n ?? u}></calcite-button><calcite-button class=${r(i(a.button, a.zoomOut))} .disabled=${!s} icon-start=minus kind=neutral .label=${c} @click=${this.zoomOut} title=${c ?? u}></calcite-button></div>`;
+  }
+}
+h("geoscene-zoom", $);
+export {
+  $ as GeosceneZoom
+};

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

@@ -0,0 +1,2 @@
+import "@esri/calcite-components/components/calcite-button";
+export * from "./customElement.js";

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

@@ -0,0 +1,2 @@
+import "@esri/calcite-components/components/calcite-button";
+export * from "./customElement.js";

package/dist/components/geoscene-zoom/utils.d.ts

@@ -0,0 +1,4 @@
+import { default as MapView } from '@geoscene/core/views/MapView.js';
+import { default as SceneView } from '@geoscene/core/views/SceneView.js';
+export declare function canZoomIn(view: MapView | SceneView): boolean;
+export declare function canZoomOut(view: MapView | SceneView): boolean;

package/dist/components/types.d.ts

@@ -0,0 +1,5 @@
+export type MeasurementSystem = "imperial" | "metric";
+type MetricMapUnit = "centimeter" | "kilometer" | "meter" | "millimeter";
+type ImperialMapUnit = "foot" | "inch" | "mile";
+export type MapUnit = ImperialMapUnit | MetricMapUnit;
+export {};

package/dist/controllers/Handles.d.ts

@@ -0,0 +1,102 @@
+import { IHandle, Nil } from '@arcgis/components-utils';
+export declare class Handles<T = string, H extends IHandle = IHandle> {
+    /**
+     * A handle to a [highlight](https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-views-layers-FeatureLayerView.html#highlight) call result.
+     * The handle can be used to remove the installed highlight.
+     *
+     * @typedef module:geoscene/core/Handles~Handle
+     *
+     * @property {Function} remove - Removes the handle.
+     */
+    /**
+     * Destroys the object, removing all the handles.
+     *
+     * @method destroy
+     * @instance
+     *
+     * @example
+     * let handles = new Handles();
+     *
+     * handles.add(reactiveUtils.when(
+     *   () => !view.updating,
+     *   () => {
+     *     wkidSelect.disabled = false;
+     *   },
+     *   { once: true }
+     * ));
+     *
+     * handles.destroy();
+     */
+    destroy(): void;
+    private _groups;
+    /**
+     * Adds a group of handles.
+     *
+     * @method add
+     * @param {module:geoscene/core/Accessor~WatchHandle | module:geoscene/core/Accessor~WatchHandle[] | module:geoscene/core/Collection<module:geoscene/core/Accessor~WatchHandle>} handles - An array or collection handles to group.
+     * @param {*} [groupKey]
+     *    Key identifying the group to which the handles should be added. All the handles in the group
+     *    can later be removed with [Handles.remove()](https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-core-Handles.html#remove). If no
+     *    key is provided the handles are added to a default group.
+     *
+     * @example
+     * let handles = new Handles();
+     *
+     * handles.add(handle); // added to the default group
+     * handles.add([handle1, handle2]); // added to the default group
+     *
+     * handles.add(handle, "handle-group");
+     * handles.add([handle1, handle2], "other-handle-group");
+     * @example
+     * let handles = new Handles();
+     *
+     * handles.add(reactiveUtils.when(
+     *   () => !view.updating,
+     *   () => {
+     *     wkidSelect.disabled = false;
+     *   },
+     *   { once: true }
+     * ));
+     * @instance
+     */
+    add(handles: (H | Nil)[] | H | Nil, groupKey?: T): this;
+    forEach(groupKey: T, callback: (handle: H) => void): void;
+    forEach(callback: (handle: H) => void): void;
+    /**
+     * Returns true if a group exists for the provided group key, false otherwise.
+     *
+     * @method has
+     * @instance
+     * @param {*} groupKey - group handle key
+     * @return {boolean}
+     */
+    has(groupKey?: T): boolean;
+    /**
+     * Removes a group of handles.
+     *
+     * @method remove
+     * @instance
+     * @param {*} [groupKey] - A group key or an array or collection of group keys to remove.
+     *
+     * @example
+     * let handles = new Handles();
+     *
+     * handles.remove(); // removes handles from default group
+     *
+     * handles.remove("handle-group");
+     * handles.remove("other-handle-group");
+     */
+    remove(groupKey?: T | T[]): this;
+    /**
+     * Removes all handles.
+     *
+     * @method removeAll
+     * @instance
+     */
+    removeAll(): this;
+    private _isHandle;
+    private _getOrCreateGroup;
+    private _getGroup;
+    private _ensureGroupKey;
+    private _removeAllFromGroup;
+}

package/dist/controllers/createCloseEvent.d.ts

@@ -0,0 +1,6 @@
+import { EventEmitter } from '@arcgis/lumina';
+export declare const createCloseEvent: (component: {
+    geosceneClose: EventEmitter;
+    autoDestroyDisabled: boolean;
+    destroy: () => void;
+} & import('@arcgis/lumina').LitElement) => EventEmitter;

package/dist/controllers/useHandles.d.ts

@@ -0,0 +1,104 @@
+import { IHandle } from '@arcgis/components-utils';
+import { Controller } from '@arcgis/lumina/controllers';
+/**
+ * Avoid accidentally adding objects that look like handles because they have a `remove` method,
+ * but are not because they can be destroyed e.g. the Handles object.
+ */
+export type SafeHandle = IHandle & {
+    destroy?: null;
+};
+/** Avoid accidentally using a handle as a group key. */
+export type GroupKey<T> = Exclude<T, IHandle>;
+declare class HandleManager extends Controller {
+    destroyed: boolean;
+    private _handles;
+    constructor(removeOn: "destroy" | "disconnect");
+    /**
+     * Adds one or more handles which are to be tied to the lifecycle of the object. The handles will
+     * be removed when the object is destroyed.
+     *
+     * ```js
+     * // Manually manage handles
+     * const handle = reactiveUtils.when(
+     *   () => !view.updating,
+     *   () => {
+     *     wkidSelect.disabled = false;
+     *   },
+     *   { once: true }
+     * );
+     *
+     * this.addHandles(handle);
+     *
+     * // Destroy the object
+     * this.destroy();
+     * ```
+     *
+     * @method addHandles
+     * @since 4.25
+     * @instance
+     * @param {module:geoscene/core/Accessor~WatchHandle | module:geoscene/core/Accessor~WatchHandle[]} handleOrHandles
+     *    Handles marked for removal once the object is destroyed.
+     * @param {*} [groupKey]
+     *    Key identifying the group to which the handles should be added. All the handles in the group
+     *    can later be removed with [Accessor.removeHandles()](https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-core-Accessor.html#removeHandles).
+     *    If no key is provided the handles are added to a default group.
+     */
+    addHandles<T>(handleOrHandles: SafeHandle | SafeHandle[], groupKey?: GroupKey<T>): void;
+    /**
+     * Removes a group of handles owned by the object.
+     *
+     * @method removeHandles
+     * @since 4.25
+     * @instance
+     * @param {*} [groupKey] - A group key or an array or collection of group keys to remove.
+     *
+     * @example
+     * obj.removeHandles(); // removes handles from default group
+     *
+     * obj.removeHandles("handle-group");
+     * obj.removeHandles("other-handle-group");
+     */
+    removeHandles<T>(groupKey?: GroupKey<T>): void;
+    /**
+     * Removes all the handles currently associated with the object.
+     *
+     * @private
+     */
+    removeAllHandles(): void;
+    destroy(): void;
+    /**
+     * Returns true if a named group of handles exist.
+     *
+     * @method hasHandles
+     * @since 4.25
+     * @instance
+     * @param {*} [groupKey] - A group key.
+     * @return {boolean} Returns `true` if a named group of handles exist.
+     *
+     * @example
+     * // Remove a named group of handles if they exist.
+     * if (obj.hasHandles("watch-view-updates")) {
+     *   obj.removeHandles("watch-view-updates");
+     * }
+     */
+    hasHandles<T>(groupKey?: GroupKey<T>): boolean;
+}
+/**
+ * useHandles() implements the following methods from JS API's Accessor class:
+ * addHandles - https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-core-Accessor.html#addHandles
+ * hasHandles - https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-core-Accessor.html#hasHandles
+ * removeHandles - https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-core-Accessor.html#removeHandles
+ * removeAllHandles - (hidden from the JS API's JSDoc)
+ *
+ * Except, to adapt these to web-components, you have an option of picking
+ * whether handles should get removed on component disconnect or destroy.
+ *
+ * destroy() is an opt-in lifecycle event provided by the controllers API.
+ * Read controllers documentation for instructions on how to opt it.
+ *
+ * Prefer using "disconnect" over "destroy" when possible
+ *
+ * @deprecated Note: you might not need useHandles. See manager.onLifecycle instead 
+ */
+export declare const useHandles: (removeOn: "destroy" | "disconnect") => HandleManager;
+export {};

package/dist/controllers/useT9n.d.ts

@@ -0,0 +1 @@
+export declare const useT9n: import('@arcgis/lumina/controllers').UseT9n;

package/dist/controllers/useView.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+import { GenericController } from '@arcgis/lumina/controllers';
+import { Nil } from '@arcgis/components-utils';
+import { default as MapView } from '@geoscene/core/views/MapView';
+import { default as SceneView } from '@geoscene/core/views/SceneView';
+import { default as LinkChartView } from '@geoscene/core/views/LinkChartView';
+import { GeosceneReferenceElement } from '../utils/component-utils';
+import { PropertyValues } from 'lit';
+import { LitElement, EventEmitter } from '@arcgis/lumina';
+type View = LinkChartView | MapView | SceneView;
+type ViewControllerRequires<ViewType extends View> = LitElement & ViewControllerUses<ViewType>;
+export interface ViewControllerUses<ViewType extends View> {
+    view?: Nil | ViewType;
+    position: __geoscene.UIPosition;
+    referenceElement?: GeosceneReferenceElement | string;
+    geosceneReady: EventEmitter;
+    el: HTMLElement & {
+        childElem?: HTMLElement & {
+            ownedBy?: HTMLElement;
+        };
+        view?: Nil | ViewType;
+    };
+}
+/**
+ * Creates a controller which adds a `view` property to the component and connects the component to that view, both when
+ * the view is provided directly or linked via the `referenceElement` property. The controller also handles emitting the
+ * `arcgisViewReady` event and removing the component from the view's UI when the component is disconnected.
+ */
+export declare const useView: <ViewType extends View = View>(component: ViewControllerRequires<ViewType>) => ViewType | undefined;
+export declare class ViewController<ViewType extends View = View> extends GenericController<ViewType | undefined, ViewControllerRequires<ViewType>> {
+    #private;
+    constructor(component: ViewControllerRequires<ViewType>);
+    hostConnected(): void;
+    hostLoad(): void;
+    hostLoaded(): void;
+    hostDisconnected(): void;
+    hostUpdate(changes: PropertyValues<ViewControllerUses<View>>): void;
+}
+export {};

package/dist/controllers/useViewModel.d.ts

@@ -0,0 +1,57 @@
+import { AccessorController } from '@arcgis/lumina/controllers/accessor';
+import { Nil } from '@arcgis/components-utils';
+import { default as Accessor } from '@geoscene/core/core/Accessor';
+import { default as Evented } from '@geoscene/core/core/Evented';
+import { default as GeosceneMap } from '@geoscene/core/Map';
+import { default as MapView } from '@geoscene/core/views/MapView';
+import { default as SceneView } from '@geoscene/core/views/SceneView';
+import { default as LinkChartView } from '@geoscene/core/views/LinkChartView';
+import { ViewControllerUses } from './useView';
+import { LitElement, EventEmitter } from '@arcgis/lumina';
+type ViewModelControllerRequires<Props, ViewModel extends ViewModelInstance> = LitElement & Pick<ViewModel, keyof Props & keyof ViewModel> & ViewModelControllerUses<ViewModel>;
+type ViewModelInstance = Accessor & Partial<Evented> & {
+    state?: string;
+    view?: LinkChartView | MapView | Nil | SceneView;
+    map?: GeosceneMap | Nil;
+};
+export interface ViewModelControllerUses<ViewModel extends ViewModelInstance> extends ViewControllerUses<NonNullable<ViewModelInstance["view"]>> {
+    state?: ViewModel["state"];
+    icon?: string;
+    label?: string;
+    geoscenePropertyChange: EventEmitter<{
+        name: string;
+    }> | undefined;
+    autoDestroyDisabled: boolean;
+    destroy: () => Promise<void>;
+}
+/**
+ * A controller for a mapping component that:
+ * - loads the viewModel
+ * - initializes the viewModel with the component's properties
+ * - does two-way binding between view model and component properties
+ * - re-emits the viewModel's events on the component
+ * - type-checks everything ✨
+ *
+ * Documentation:
+ * 
+ *
+ * TEST: add test cases for this controller
+ */
+export declare const makeViewModelController: <Props, ViewModel extends ViewModelInstance, OmitProps extends string = never>(loadViewModel: ((props?: Omit<Props, "view">) => ViewModel) | (new (props?: Omit<Props, "view">) => ViewModel), _options?: {
+    /**
+     * Don't expose the following ViewModels's properties on the component.
+     * You can also bind the property to \@State rather than \@Prop if you
+     * wish to use it internally only:
+     *
+     * @example
+     * \@State() timeZone = this.viewModel.timeZone;
+     */
+    omitProps: OmitProps[];
+}) => (component: ViewModelControllerRequires<Omit<Props, OmitProps>, ViewModel>) => ViewModel;
+export declare class ViewModelController<Props, ViewModel extends ViewModelInstance> extends AccessorController<Props, ViewModel, ViewModelControllerUses<ViewModel>> {
+    #private;
+    constructor(component: ViewModelControllerRequires<Props, ViewModel>, loadViewModel: ((props?: Omit<Props, "view">) => ViewModel) | (new (props?: Omit<Props, "view">) => ViewModel));
+    hostLoad(): void;
+    hostDestroy(): void;
+}
+export {};

package/dist/controllers/useWidget.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+import { AccessorController } from '@arcgis/lumina/controllers/accessor';
+import { Nil } from '@arcgis/components-utils';
+import { default as GeosceneMap } from '@geoscene/core/Map';
+import { GeosceneReferenceElement } from '../utils/component-utils';
+import { LitElement, EventEmitter } from '@arcgis/lumina';
+import { PropertyValues } from 'lit';
+type Requires<Props, Widget extends WidgetInstance> = LitElement & Pick<Widget, keyof Props & keyof Widget> & Uses<Widget>;
+type WidgetInstance = __geoscene.Widget & {
+    state?: string;
+    viewModel?: __geoscene.Accessor & {
+        state?: string;
+        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView | Nil;
+        map?: GeosceneMap | Nil;
+    };
+    view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView | Nil;
+    map?: GeosceneMap | Nil;
+    visibleElements?: Record<never, unknown>;
+};
+type Uses<Widget extends WidgetInstance> = {
+    state?: Exclude<Widget["viewModel"], Nil>["state"] | Widget["state"];
+    viewModel?: Widget["viewModel"];
+    closed?: boolean;
+    icon: Nil | string;
+    label: Nil | string;
+    referenceElement?: GeosceneReferenceElement | string;
+    position: __geoscene.UIPosition;
+    geosceneReady: EventEmitter;
+    geoscenePropertyChange: EventEmitter<{
+        name: string;
+    }> | undefined;
+    el: HTMLElement & {
+        childElem?: HTMLElement & {
+            ownedBy?: HTMLElement;
+        };
+        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView;
+    };
+    autoDestroyDisabled: boolean;
+    destroy: () => Promise<void>;
+};
+/**
+ * A controller for a wrapped JS API Widget
+ * - loads the widget
+ * - initializes the widget with the component's properties
+ * - does two-way binding between widget and component properties
+ * - re-emits the widgets's events on the component
+ * - type-checks everything ✨
+ *
+ * Documentation:
+ * https://qawebgis.geoscene.cn/components/lumina/transition-from-widgets#usewidget-controller
+ */
+export declare const makeWidgetController: <Props, Widget extends WidgetInstance, OmitProps extends string = never>(createWidget: ((props?: Props) => Widget) | (new (props?: Props) => Widget), _options?: {
+    /**
+     * Don't expose the following Widget's properties on the component.
+     * You can also bind the property to \@State rather than \@Prop if you
+     * wish to use it internally only:
+     *
+     * @example
+     * \@state() timeZone = this.widget.timeZone;
+     */
+    omitProps: OmitProps[];
+}) => (component: Requires<Omit<Props, OmitProps | "container" | "id" | "view" | "visible" | "visibleElements">, Widget>) => Widget;
+export declare class WidgetController<Props, Widget extends WidgetInstance> extends AccessorController<Props, Widget, Uses<Widget>> {
+    #private;
+    constructor(component: Requires<Props, Widget> & Uses<Widget>, createWidget: ((props?: Props) => Widget) | (new (props?: Props) => Widget));
+    hostConnected(): void;
+    hostLoad(): void;
+    hostUpdate(changes: PropertyValues<Uses<Widget>>): void;
+    hostLoaded(): void;
+    hostDestroy(): void;
+}
+export {};