/// <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 {};