@geoscene/map-components 4.33.18

package/dist/components/geoscene-line-of-sight/customElement.d.ts

@@ -0,0 +1,149 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { PublicLitElement as LitElement, JsxNode, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+import { default as LineOfSightViewModel } from './LineOfSightViewModel';
+
+declare const useViewModel: (component: LitElement & Pick<LineOfSightViewModel, never> & import('../../controllers/useViewModel').ViewModelControllerUses<LineOfSightViewModel>) => LineOfSightViewModel;
+/**
+ * The Line Of Sight component is a 3D analysis tool that allows you to perform
+ * [line of sight visibility analysis](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-LineOfSightAnalysis.html)
+ * in a [Scene](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/). Visibility between a given observer and multiple target points is calculated against the currently
+ * displayed content in the view, including the ground, integrated meshes, and 3D objects such as buildings or trees.
+ *
+ * ![line-of-sight](https://doc.geoscene.cn/javascript/4.33/assets/img/apiref/widgets/line-of-sight.png)
+ *
+ * The analysis results are displayed as colored lines, where areas visible to the observer are
+ * shown green and occluded parts are marked in red. Also, the color of the target points indicates their visibility.
+ * When the line of sight cannot be calculated, it will be displayed with a gray color. This may happen if either
+ * the target or the observer is not in the view.
+ *
+ * When creating a new line of sight analysis, the first click in the Scene creates the
+ * [observer](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-LineOfSightAnalysisObserver.html)
+ * and subsequent clicks place the [targets](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-LineOfSightAnalysisTarget.html).
+ * Both the observer and target points can be moved by dragging. Additionally, the target points can be removed with a right click.
+ *
+ * **Known limitation**
+ *
+ * Line Of Sight is only supported in a 3D [Scene](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/) component.
+ *
+ * **See also**
+ *
+ * - [LineOfSightAnalysis](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-LineOfSightAnalysis.html)
+ * - [Sample - Line of sight component](https://doc.geoscene.cn/javascript/4.33/sample-code/line-of-sight/)
+ * - [Sample - Analysis objects](https://doc.geoscene.cn/javascript/4.33/sample-code/analysis-objects/)
+ *
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-line-of-sight/)
+ */
+export declare class GeosceneLineOfSight extends LitElement {
+    /**
+     * The [LineOfSightAnalysis](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-LineOfSightAnalysis.html)
+     * created or modified by the component.
+     *
+     * When connecting the Line Of Sight component to the [Scene](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/)
+     * component, it automatically creates an empty analysis and adds it to the Scene's
+     * [analyses](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/#analyses) collection.
+     * Whenever the component is destroyed, the analysis is automatically removed from the collection.
+     *
+     * Alternatively, a programmatically created analysis can be provided to the component.
+     * Then, the application itself needs to add it to and later remove it from the Scene's analyses collection.
+     *
+     * ```js
+     * //Create the analysis.
+     * const lineOfSightAnalysis = new LineOfSightAnalysis({
+     *   observer: new LineOfSightAnalysisObserver({
+     *         position: new Point({
+     *         spatialReference: { latestWkid: 3857, wkid: 102100 },
+     *         x: -13624828.3377593,
+     *         y: 4550305.319405007,
+     *         z: 105.55410975124687
+     *         }),
+     *   }),
+     *   targets: [ new LineOfSightAnalysisTarget({
+     *         position: new Point({
+     *         spatialReference: { latestWkid: 3857, wkid: 102100 },
+     *         x: -13624944.17687458,
+     *         y: 4550420.577689567,
+     *         z: 0
+     *         }),
+     *   })
+     * ]
+     * });
+     * // Get the Scene and Line Of Sight component and wait until they are ready.
+     * const viewElement = document.querySelector("geoscene-scene");
+     * await viewElement.viewOnReady();
+     * const lineOfSight = document.querySelector("geoscene-line-of-sight");
+     * await lineOfSight.componentOnReady();
+     * // Add the analysis to the Scene component.
+     * viewElement.analyses.add(lineOfSightAnalysis);
+     * // Connect the analysis to the component:
+     * lineOfSight.analysis = lineOfSightAnalysis;
+     * ```
+     */
+    analysis: __geoscene.LineOfSightAnalysis;
+    /**
+     * 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-line-of-sight/#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 "line-of-sight"
+     */
+    icon?: HTMLCalciteIconElement["icon"];
+    /** The component's default label. */
+    label?: string;
+    /**
+     * Replace localized message strings with your own strings.
+     *
+     * _**Note**: Individual message keys may change between releases._
+     */
+    messageOverrides?: typeof this._messages._overrides;
+    /** @default "bottom-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 component's state. The values mean the following:
+     *
+     * * `disabled` -  not ready yet
+     * * `ready` - ready for analysis
+     * * `creating` - observer/target points are being placed
+     * * `created` - finished analysis
+     */
+    get state(): "created" | "creating" | "disabled" | "ready";
+    /** Clear the current analysis results. After calling this method, the user can set a new observer and targets. */
+    clear(): Promise<void>;
+    /** After [stop()](#stop) was called, this method allows to continue the line of sight analysis and add more targets. */
+    continue(): Promise<void>;
+    /** Permanently destroy the component. */
+    destroy(): Promise<void>;
+    /** Start a new line of sight analysis. */
+    start(): Promise<void>;
+    /**
+     * Stop the current placing of line of sight analysis. Any lines added this far are kept  in the view.
+     * Users can still interact with existing targets and the observer, but they cannot place new target points.
+     */
+    stop(): 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" | "analysis";
+    }>;
+    /** 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;
+}
+export {};

package/dist/components/geoscene-line-of-sight/customElement.js

@@ -0,0 +1,113 @@
+import { c as f } from "../../chunks/runtime.js";
+import { html as l } from "lit-html";
+import { usePropertyChange as m } from "@arcgis/lumina/controllers";
+import { LitElement as y, createEvent as v, noShadowRoot as _, safeClassMap as n } from "@arcgis/lumina";
+import { css as w } from "@lit/reactive-element/css-tag.js";
+import { g } from "../../chunks/globalCss.js";
+import { u as $ } from "../../chunks/useT9n.js";
+import { m as b } from "../../chunks/useViewModel.js";
+import { A as M } from "../../chunks/AnalysisViewModel.js";
+import x from "@geoscene/core/analysis/LineOfSightAnalysis.js";
+import { property as O, subclass as A } from "@geoscene/core/core/accessorSupport/decorators.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 C = w`@layer{geoscene-line-of-sight{display:block}.geoscene-line-of-sight__container{display:flex;position:relative;flex-flow:column;gap:var(--calcite-spacing-md);padding:var(--geoscene-widget-padding);overflow-y:auto}.geoscene-line-of-sight__error{color:var(--calcite-color-status-danger)}.geoscene-line-of-sight__hint{display:flex;flex-direction:column;gap:var(--calcite-spacing-md)}.geoscene-line-of-sight__error,.geoscene-line-of-sight__hint{overflow:hidden;animation:geoscene-line-of-sight-fade-in .25s ease-in-out;p{margin:0;padding:0}}.geoscene-line-of-sight__actions{display:flex;flex-flow:column;gap:var(--calcite-spacing-xxs);justify-content:center}@keyframes geoscene-line-of-sight-fade-in{0%{opacity:0}25%{opacity:0}to{opacity:1}}}`, a = "geoscene-line-of-sight", r = {
+  base: a,
+  actions: `${a}__actions`,
+  container: `${a}__container`,
+  error: `${a}__error`,
+  hint: `${a}__hint`,
+  hintText: `${a}__hint-text`,
+  newAnalysisButton: `${a}__new-analysis-button`
+};
+var S = Object.defineProperty, D = Object.getOwnPropertyDescriptor, u = (t, e, i, o) => {
+  for (var s = o > 1 ? void 0 : o ? D(e, i) : e, d = t.length - 1, h; d >= 0; d--)
+    (h = t[d]) && (s = (o ? h(e, i, s) : h(s)) || s);
+  return o && s && S(e, i, s), s;
+};
+let c = class extends M {
+  constructor() {
+    super(...arguments), this.supportedViewType = "3d", this.unsupportedErrorMessage = "The Line Of Sight component is only supported in 3D views.";
+  }
+  get state() {
+    return this.disabled || !this.ready ? "disabled" : this.operationState === "active" ? "creating" : this.analysis.valid ? "created" : "ready";
+  }
+  constructAnalysis() {
+    return new x();
+  }
+  clearAnalysis() {
+    this.analysis.observer = null, this.analysis.targets.removeAll();
+  }
+  async place(t) {
+    await this.analysisView?.place(t);
+  }
+};
+u([
+  O({ readOnly: !0 })
+], c.prototype, "state", 1);
+c = u([
+  A("geoscene.components.LineOfSight.LineOfSightViewModel")
+], c);
+const L = b(c);
+class V extends y {
+  constructor() {
+    super(...arguments), this.viewModel = L(this), this._messages = $({ blocking: !0 }), this.view = this.viewModel.view, this.analysis = this.viewModel.analysis, this.autoDestroyDisabled = !1, this.icon = "line-of-sight", this.position = "bottom-left", this.geoscenePropertyChange = m()("analysis", "state"), this.geosceneReady = v();
+  }
+  static {
+    this.properties = { analysis: 0, autoDestroyDisabled: 5, icon: 3, label: 1, messageOverrides: 0, position: 1, referenceElement: 1, state: 35, _supported: 16 };
+  }
+  static {
+    this.shadowRootOptions = _;
+  }
+  static {
+    this.styles = C;
+  }
+  get state() {
+    return this.viewModel.state;
+  }
+  get _supported() {
+    return this.view == null || this.view.type === "3d";
+  }
+  async clear() {
+    this.viewModel.clear();
+  }
+  async continue() {
+    this.viewModel.start();
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+  async start() {
+    this.viewModel.startNewAnalysis();
+  }
+  async stop() {
+    this.viewModel.stop();
+  }
+  render() {
+    return l`<div class=${n({
+      [r.base]: !0,
+      [g.widget]: !0,
+      [g.panel]: !0
+    })} role=presentation>${this._renderContainerNode()}</div>`;
+  }
+  _renderContainerNode() {
+    if (!this._supported)
+      return l`<div class=${n(r.error)}><p>${this._messages.unsupported}</p></div>`;
+    const e = this.viewModel.state, i = e === "creating";
+    return l`<div class=${n(r.container)}>${i ? l`<div class=${n(r.hint)}><p class=${n(r.hintText)}>${this._messages.hint}</p></div>` : null}<div class=${n(r.actions)}>${e === "creating" ? p({ onClick: () => {
+      this.stop();
+    }, children: this._messages.done }) : null}${e === "created" ? p({ onClick: () => {
+      this.continue();
+    }, children: this._messages.continueAnalysis }) : null}${p({ className: r.newAnalysisButton, onClick: () => {
+      this.start();
+    }, primary: !0, disabled: e === "disabled", children: this._messages.newAnalysis })}</div></div>`;
+  }
+}
+function p({ className: t, onClick: e, primary: i, disabled: o, children: s }) {
+  return l`<calcite-button .appearance=${i ? "solid" : "outline-fill"} class=${n(t)} .disabled=${o} @click=${e}>${s}</calcite-button>`;
+}
+f("geoscene-line-of-sight", V);
+export {
+  V as GeosceneLineOfSight
+};

package/dist/components/geoscene-line-of-sight/index.d.ts

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

package/dist/components/geoscene-line-of-sight/index.js

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

package/dist/components/geoscene-link-chart/customElement.d.ts

@@ -0,0 +1,365 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { Nil } from '@arcgis/components-utils';
+import { default as LinkChartView } from '@geoscene/core/views/LinkChartView.js';
+import { default as WebLinkChart } from '@geoscene/core/WebLinkChart.js';
+import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+
+declare const useWebLinkChart: (component: LitElement & Omit<Pick<WebLinkChart, "basemap" | "focusAreas" | "ground" | "layers" | "bookmarks" | "tables" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "floorInfo" | "initialViewProperties" | "linkChartProperties" | "mapType" | "portalItem" | "thumbnailUrl">, "basemap" | "ground" | ("destroyed" | "initialized" | "declaredClass" | "set" | "watch" | "addHandles" | "removeHandles" | "hasHandles") | "layers" | "bookmarks" | "tables" | "presentation" | "knowledgeGraph" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "entityCount" | "floorInfo" | "geotriggersInfo" | "initialViewProperties" | "linkChartProperties" | "mapType" | "portalItem" | "relationshipCount" | "thumbnailUrl"> & {
+    autoDestroyDisabled: boolean;
+    destroy: () => Promise<void>;
+}) => WebLinkChart;
+declare const useLinkChartView: (component: LitElement & Omit<Pick<LinkChartView, "container" | "map" | "background" | "basemapView" | "center" | "constraints" | "extent" | "fatalError" | "graphics" | "highlights" | "navigation" | "padding" | "popup" | "resizeAlign" | "rotation" | "scale" | "spatialReference" | "theme" | "timeExtent" | "timeZone" | "viewpoint" | "zoom" | "floors" | "highlightOptions" | "breakpoints" | "heightBreakpoint" | "popupEnabled" | "spatialReferenceLocked" | "widthBreakpoint" | "ui" | "animation" | "displayFilterEnabled">, "container" | "floors" | "highlightOptions" | ("destroyed" | "initialized" | "declaredClass" | "set" | "watch" | "addHandles" | "removeHandles" | "hasHandles") | "breakpoints" | "heightBreakpoint" | "popupEnabled" | "spatialReferenceLocked" | "widthBreakpoint" | "ui" | "animation" | "displayFilterEnabled"> & {
+    autoDestroyDisabled: boolean;
+    destroy: () => Promise<void>;
+}) => LinkChartView;
+/**
+ * Loads a [WebLinkChart](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-WebLinkChart.html) from an [GeoScene Enterprise portal](https://enterprise.geoscene.cn/en/portal/latest/administer/windows/what-is-portal-for-geoscene-.htm) into a [LinkChartView](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-LinkChartView.html).
+ *
+ *
+ * Note: Sign in to access the data in this demo, U/P: `viewer01`/`I68VGU^nMurF`
+ *
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-link-chart/)
+ */
+export declare class GeosceneLinkChart extends LitElement {
+    /** Internal view of the component. */
+    readonly view: LinkChartView;
+    /**
+     * Collection containing a flat list of all the created LayerViews
+     * related to the basemap, operational layers, and group layers in this view.
+     */
+    readonly allLayerViews: __geoscene.Collection<__geoscene.LayerView>;
+    /**
+     * 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-link-chart/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
+     */
+    autoDestroyDisabled: boolean;
+    /**
+     * The background color of the LinkChartView. If the view's link chart changes, the view's `background` is reset to the link chart's background,
+     * even if the user set it previously.
+     *
+     * @default null
+     */
+    background: nullish | __geoscene.ColorBackground;
+    /**
+     * Specifies a basemap for the link chart. The basemap is only visible when the link
+     * chart is set to a geographic layout. See
+     * [documentation on layouts](https://enterprise.geoscene.cn/en/knowledge/latest/knowledge-studio/change-the-layout-applied-to-a-link-chart.htm)
+     * for more detail. The basemap is a set of layers that give
+     * geographic context to the LinkChartView and the other operational layers
+     * in the link chart.
+     */
+    basemap?: __geoscene.Basemap | string;
+    /** Represents the view for a single basemap after it has been added to the link chart. */
+    basemapView: __geoscene.BasemapView;
+    /**
+     * Represents the view's center point; when setting the center, you may pass a
+     * geoscene/geometry/Point instance or a string representing
+     * a longitude/latitude pair (`"-100.4593, 36.9014"`).
+     * Setting the center immediately changes the current view.
+     * For animating the view, see this component's goTo() method.
+     */
+    get center(): __geoscene.LinkChartView["center"];
+    set center(newValue: __geoscene.LinkChartView["center"] | Nil | number[] | string);
+    /** Specifies constraints to scale, zoom, and rotation that may be applied to the LinkChartView. */
+    constraints: __geoscene.View2DConstraints;
+    /**
+     * Indicates whether layer's displayFilter are honored when rendering layers in the view.
+     * If `false`, display filters are ignored and all features are rendered.
+     *
+     * @default false
+     */
+    displayFilterDisabled: boolean;
+    /**
+     * The extent represents the visible portion of a link chart within the view as an instance of
+     * [Extent](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-geometry-Extent.html).
+     * Setting the extent immediately changes the view without animation. To animate
+     * the view, see this component's goTo() method.
+     * When the view is rotated, the extent does not update to include the newly visible portions of the link chart.
+     */
+    get extent(): __geoscene.LinkChartView["extent"];
+    set extent(newValue: __geoscene.LinkChartView["extent"]);
+    /** A rejected view indicates a fatal error making it unable to display. */
+    fatalError: nullish | __geoscene.Error;
+    /**
+     * Allows for adding graphics directly to the default graphics in the View.
+     *
+     * @example
+     * ```js
+     * // Adds a graphic to the View
+     * graphics.add(pointGraphic);
+     * ```
+     * @example
+     * ```js
+     * // Removes a graphic from the View
+     * graphics.remove(pointGraphic);
+     * ```
+     */
+    graphics: __geoscene.Collection<__geoscene.Graphic>;
+    /**
+     * The highlights property is a collection of HighlightGroup objects that
+     * allow you to visually emphasize specific features on the link chart.
+     */
+    highlights: __geoscene.Collection<__geoscene.HighlightOptions>;
+    /**
+     * Indication whether the view is being interacted with (for example when panning or by an interactive tool).
+     *
+     * @default false
+     */
+    get interacting(): boolean;
+    /**
+     * The ID of a WebLinkChart from an GeoScene Enterprise portal.
+     *
+     * To configure the portal url you must set the [`portalUrl` property on `config`](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-config.html#portalUrl) before the Link Chart component loads.
+     */
+    get itemId(): Nil | string;
+    set itemId(newValue: Nil | string);
+    /**
+     * A collection containing a hierarchical list of all the created
+     * [LayerViews](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-layers-LayerView.html) of the
+     * [operational layers](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-WebLinkChart.html#layers) in the link chart.
+     */
+    readonly layerViews: __geoscene.Collection<__geoscene.LayerView>;
+    /** The magnifier allows for showing a portion of the view as a magnifier image on top of the view. */
+    readonly magnifier: __geoscene.Magnifier;
+    /**
+     * An instance of a [WebLinkChart](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-WebLinkChart.html)
+     * object to display in the view.
+     */
+    map: WebLinkChart | nullish;
+    /**
+     * Indication whether the view is being navigated (for example when panning).
+     *
+     * @default false
+     */
+    get navigating(): boolean;
+    /** Options to configure the navigation behavior of the View. */
+    navigation: __geoscene.Navigation;
+    /**
+     * Use the padding property to make the [center](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-MapView.html#center),
+     * and [extent](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-MapView.html#extent), etc.
+     *
+     * @default {left: 0, top: 0, right: 0, bottom: 0}
+     */
+    padding: __geoscene.ViewPadding;
+    /**
+     * A [Popup](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Popup.html) object that displays general content or attributes from
+     * [layers](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Map.html#layers) in the [map](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-View2D.html#map).
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-View2D.html#popup)
+     */
+    popup: nullish | __geoscene.Popup;
+    /**
+     * Controls whether the popup opens when users click on the view.
+     *
+     * @default false
+     */
+    popupDisabled: boolean;
+    /**
+     * When `true`, this property indicates whether the view successfully satisfied all dependencies,
+     * signaling that the following conditions are met.
+     *
+     * @default false
+     */
+    readonly ready: boolean;
+    /**
+     * Defines which anchor stays still while resizing the browser window. The default, `center`,
+     * ensures the view's center point remains constantly visible as the window size changes. The other
+     * options allow  the respective portion of the view to remain visible when the window's size is changed.
+     *
+     * @default "center"
+     */
+    resizeAlign: "center" | "bottom-left" | "bottom-right" | "top-left" | "top-right" | "left" | "right" | "top" | "bottom";
+    /**
+     * Represents the current value of one pixel in the unit of the view's spatialReference.
+     * The value of resolution is calculated by dividing the view's extent width
+     * by its width.
+     */
+    readonly resolution: number;
+    /**
+     * The clockwise rotation of due north in relation to the top of the view in degrees.
+     * The view may be rotated by directly setting
+     * the rotation or by using the following mouse event: `Right-click + Drag`.
+     * WebLinkChart rotation may be disabled by setting the `rotationEnabled` property
+     * in [constraints](#constraints) to `false`.
+     *
+     * @default 0
+     */
+    rotation: number;
+    /**
+     * Represents the link chart scale at the center of the view. Setting the scale immediately changes the view. For animating
+     * the view, see this component's goTo() method.
+     */
+    get scale(): number;
+    set scale(newValue: number);
+    /**
+     * The spatial reference of the view.
+     * This indicates the projected or geographic coordinate system used
+     * to locate geographic features in the link chart.
+     *
+     * @default null
+     */
+    spatialReference: __geoscene.SpatialReference;
+    /**
+     * Indication whether the view is animating, being navigated with or resizing.
+     *
+     * @default false
+     */
+    get stationary(): boolean;
+    /**
+     * Indicates if the view is visible on the page.
+     *
+     * @default true
+     */
+    readonly suspended: boolean;
+    /**
+     * This property specifies the base colors used by some widgets
+     * and components to render graphics and labels.
+     *
+     * @default null
+     */
+    theme: nullish | __geoscene.Theme;
+    /**
+     * The view's time extent. Time-aware layers display their temporal data that falls within
+     * the view's time extent. Setting the view's time extent is similar to setting the spatial
+     * extent because once the time extent is set, the
+     * view updates automatically to conform to the change.
+     *
+     * @default null
+     */
+    timeExtent: nullish | __geoscene.TimeExtent;
+    /**
+     * Defines the time zone of the view.
+     * The time zone property determines how dates and times are represented to the user,
+     * but the underlying data is unchanged.
+     *
+     * @default "system"
+     */
+    timeZone: string;
+    /**
+     * Indicates whether the view is being updated by additional data requests to the network,
+     * or by processing received data.
+     *
+     * @default false
+     */
+    readonly updating: boolean;
+    /**
+     * Represents the current view as a Viewpoint or point of observation on the view.
+     * Setting the viewpoint immediately changes the current view. For animating
+     * the view, see this component's goTo() method.
+     */
+    get viewpoint(): __geoscene.Viewpoint;
+    set viewpoint(newValue: __geoscene.Viewpoint);
+    /**
+     * Represents the level of detail (LOD) at the center of the view.
+     * A zoom level (or scale) is a number that defines how large or small the contents of a link chart appear in a link chart view.
+     * Zoom level is a number usually between 0 (global view) and 23 (very detailed view) and is used as a shorthand for predetermined scale values.
+     * A value of -1 means the view has no LODs.
+     * When setting the zoom value, the LinkChartView converts it to the corresponding scale, or interpolates it if the zoom is a fractional number.
+     * LinkChartView can display link charts with different projections at a full range of scales, and so use the scale property on this component rather than zoom level.
+     *
+     * Setting the zoom immediately changes the current view. For animating the view, see this component's goTo() method.
+     * Setting this property in conjunction with `center` is a convenient way to set the initial extent of the view.
+     */
+    get zoom(): number;
+    set zoom(newValue: number);
+    /**
+     * @deprecated
+     * since 4.33, use `element.map.add(layer)` instead.
+     *
+     * Adds a layer to the map layers collection.
+     */
+    addLayer(layer: __geoscene.Layer | Promise<any>, index?: number): Promise<void>;
+    /**
+     * @deprecated
+     * since 4.33, use `element.map.addMany([layer])` instead.
+     *
+     * Adds a layer or array of layers to the map layers collection.
+     */
+    addLayers(layers: __geoscene.Layer[], index?: number): Promise<void>;
+    /** Closes the popup. */
+    closePopup(): Promise<void>;
+    /** Destroys the view, and any associated resources, including its map, popup, and UI elements. */
+    destroy(): Promise<void>;
+    /** Sets the view to a given target. */
+    goTo(target: __geoscene.GoToTarget2D, options?: __geoscene.GoToOptions2D): Promise<unknown>;
+    /**
+     * Opens the popup at the given location with content defined either explicitly with content or driven
+     * from the PopupTemplate of input features.
+     */
+    openPopup(options?: __geoscene.PopupViewOpenPopupOptions): Promise<void>;
+    toMap(screenPoint: __geoscene.MapViewScreenPoint | MouseEvent): __geoscene.Point;
+    toScreen(point: __geoscene.Point, options?: __geoscene.ToScreenOptions2D): __geoscene.MapViewScreenPoint | nullish;
+    /** Call this method to clear any fatal errors resulting from a lost WebGL context. */
+    tryFatalErrorRecovery(): Promise<void>;
+    /** Gets the LayerView created on the view for the given layer. */
+    whenLayerView(layer: __geoscene.Layer): Promise<__geoscene.LayerView>;
+    /**
+     * `viewOnReady()` may be leveraged once an instance of the component and its underlying [view](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-link-chart/#view) is created and ready.
+     * This method takes two input parameters, a `callback` function and an `errback` function, and returns a promise. The `callback` executes when the promise resolves, and the `errback` executes if the promise is rejected.
+     *
+     * @since 4.33
+     * @see [Watch for changes - waiting for components or views to be ready](https://doc.geoscene.cn/javascript/4.33/watch-for-changes/#waiting-for-components-or-views-to-be-ready)
+     * @example
+     * ```js
+     * const viewElement = document.querySelector("geoscene-link-chart");
+     * await viewElement.viewOnReady();
+     * // The view is now ready to be used.
+     * ```
+     */
+    viewOnReady(callback?: () => void, errback?: (error: Error) => void): Promise<void>;
+    /**
+     * This event is for view related property changes: zoom, scale, center, rotation, extent, camera, viewpoint.
+     * This event will also emit if stationary toggles from true to false.
+     */
+    readonly geosceneViewChange: TargetedEvent<this, void>;
+    /** Fires after a user clicks on the view. */
+    readonly geosceneViewClick: TargetedEvent<this, __geoscene.ViewClickEvent>;
+    /** Fires after double-clicking on the view. */
+    readonly geosceneViewDoubleClick: TargetedEvent<this, __geoscene.ViewDoubleClickEvent>;
+    /** Fires during a pointer drag on the view. */
+    readonly geosceneViewDrag: TargetedEvent<this, __geoscene.ViewDragEvent>;
+    /** Fires during a pointer drag on the view. */
+    readonly geosceneViewHold: TargetedEvent<this, __geoscene.ViewHoldEvent>;
+    /** Fires right after a user clicks on the view. */
+    readonly geosceneViewImmediateClick: TargetedEvent<this, __geoscene.ViewImmediateClickEvent>;
+    /** Is emitted after two consecutive immediate-click events. */
+    readonly geosceneViewImmediateDoubleClick: TargetedEvent<this, __geoscene.ViewImmediateDoubleClickEvent>;
+    /** Fires after a keyboard key is pressed. */
+    readonly geosceneViewKeyDown: TargetedEvent<this, __geoscene.ViewKeyDownEvent>;
+    /** Fires after a keyboard key is pressed. */
+    readonly geosceneViewKeyUp: TargetedEvent<this, __geoscene.ViewKeyUpEvent>;
+    /** Fires after each layer in the link chart has a corresponding LayerView created and rendered in the view. */
+    readonly geosceneViewLayerviewCreate: TargetedEvent<this, __geoscene.ViewLayerviewCreateEvent>;
+    /** Fires when an error emits during the creation of a LayerView after a layer has been added to the link chart. */
+    readonly geosceneViewLayerviewCreateError: TargetedEvent<this, __geoscene.ViewLayerviewCreateErrorEvent>;
+    /** Fires after a LayerView is destroyed and is no longer rendered in the view. */
+    readonly geosceneViewLayerviewDestroy: TargetedEvent<this, __geoscene.ViewLayerviewDestroyEvent>;
+    /** Fires when a wheel button of a pointing device (typically a mouse) is scrolled on the view. */
+    readonly geosceneViewMouseWheel: TargetedEvent<this, __geoscene.ViewMouseWheelEvent>;
+    /** Fires after a mouse button is pressed, or a finger touches the display. */
+    readonly geosceneViewPointerDown: TargetedEvent<this, __geoscene.ViewPointerDownEvent>;
+    /** Fires after a mouse cursor enters the view, or a display touch begins. */
+    readonly geosceneViewPointerEnter: TargetedEvent<this, __geoscene.ViewPointerEnterEvent>;
+    /** Fires after a mouse cursor leaves the view, or a display touch ends. */
+    readonly geosceneViewPointerLeave: TargetedEvent<this, __geoscene.ViewPointerLeaveEvent>;
+    /** Fires after the mouse or a finger on the display moves. */
+    readonly geosceneViewPointerMove: TargetedEvent<this, __geoscene.ViewPointerMoveEvent>;
+    /** Fires after a mouse button is released, or a display touch ends. */
+    readonly geosceneViewPointerUp: TargetedEvent<this, __geoscene.ViewPointerUpEvent>;
+    /**
+     * This event is for the `ready` property and will be emitted when the view is ready.
+     * This event will also emit if the `map` property is changed.
+     */
+    readonly geosceneViewReadyChange: TargetedEvent<this, void>;
+    readonly _setterTypes: {
+        center?: __geoscene.LinkChartView["center"] | Nil | number[] | string;
+    };
+}
+export {};