@arcgis/map-components 5.0.0-next.10 → 5.0.0-next.100

package/dist/components/arcgis-building-discipline-tree/building-discipline-view-model.d.ts

@@ -0,0 +1,76 @@
+import { default as Collection } from '@arcgis/core/core/Collection.js';
+import { default as Accessor } from '@arcgis/core/core/Accessor.js';
+import { default as BuildingSceneLayer } from '@arcgis/core/layers/BuildingSceneLayer.js';
+import { LayerTreeNode } from './layer-tree-node';
+import { default as BuildingComponentSublayer } from '@arcgis/core/layers/buildingSublayers/BuildingComponentSublayer';
+import { default as BuildingGroupSublayer } from '@arcgis/core/layers/buildingSublayers/BuildingGroupSublayer';
+import { ConstructorProps } from '../../utils/types';
+type State = "disabled" | "failed" | "loading" | "ready";
+type BuildingDisciplineViewModelProperties = ConstructorProps<BuildingDisciplineViewModel, "layers" | "root" | "state">;
+export type BuildingSublayerUnion = BuildingComponentSublayer | BuildingGroupSublayer;
+/**
+ * View model which implements the business logic for dealing with Categories
+ * and Disciplines in the Building Explorer widget.
+ */
+export default class BuildingDisciplineViewModel extends Accessor {
+    #private;
+    constructor(properties?: BuildingDisciplineViewModelProperties);
+    protected initialize(): void;
+    destroy(): void;
+    /**
+     * The root node of the tree.
+     */
+    readonly root: LayerTreeNode;
+    /**
+     * The layers to from which we'll read the categories and disciplines.
+     */
+    get layers(): Collection<BuildingSceneLayer>;
+    set layers(value: Collection<BuildingSceneLayer>);
+    /**
+     * The current state of the view model.
+     */
+    readonly state: State;
+    /**
+     * Initializes our internal tree with all the categories and disciplines from
+     * all the layers.
+     */
+    private updateLayerTree;
+    /**
+     * Adds a node to control the specified layer. If a node already exists with
+     * the same `id` (i.e. same `modelName`), we simply add the layer to that node.
+     * This also recursively adds nodes for any sublayers.
+     *
+     * @param layer
+     *    The layer which is to be controlled by the node.
+     * @param parentNode
+     *    The node to which the new nodes are to be added.
+     * @param nodes
+     *    Map with all the nodes already added.
+     * @param matchBy
+     *    The sublayer property used to deduplicate sublayers.
+     */
+    private addNodeForLayer;
+    /**
+     * Adds nodes for all the sublayers of the specified layer.
+     *
+     * @param layer
+     *    The layer whose sublayers are to be traversed.
+     * @param parentNode
+     *    The node to which new nodes are to be added.
+     * @param nodes
+     *    Map with all the nodes already added.
+     * @param matchBy
+     *    The sublayer property used to deduplicate sublayers.
+     */
+    private addNodesForSublayers;
+    /**
+     * Loads all the specified layers, stopping any previous loads if called
+     * multiple times.
+     */
+    private loadLayers;
+    /**
+     * Called when the layers are changed.
+     */
+    private _onLayersChange;
+}
+export {};

package/dist/components/arcgis-building-discipline-tree/customElement.d.ts

@@ -0,0 +1,15 @@
+/// <reference path="../../index.d.ts" />
+import { PublicLitElement as LitElement, JsxNode, TargetedEvent } from '@arcgis/lumina';
+import { Messages as BuildingExplorerMessages } from '../arcgis-building-explorer/customElement.js';
+import { default as BuildingSceneLayer } from '@arcgis/core/layers/BuildingSceneLayer';
+
+type Messages = BuildingExplorerMessages["disciplines"];
+/** [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-building-discipline-tree/) */
+export declare class BuildingDisciplineTree extends LitElement {
+    get layers(): BuildingSceneLayer[];
+    set layers(value: BuildingSceneLayer[]);
+    messages?: Messages;
+    /** @default false */
+    toggleSiblingsVisibility: boolean;
+}
+export {};

package/dist/components/arcgis-building-discipline-tree/customElement.js

@@ -0,0 +1,278 @@
+import { c as L } from "../../chunks/runtime.js";
+import { css as S, html as p } from "lit";
+import { LitElement as V, nothing as $ } from "@arcgis/lumina";
+import y from "@arcgis/core/core/Collection.js";
+import m from "@arcgis/core/core/Accessor.js";
+import { property as a, subclass as v } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { c as O, a as A } from "../../chunks/building-layer-utils.js";
+import { watch as b, on as E } from "@arcgis/core/core/reactiveUtils.js";
+import { a as D } from "../../chunks/async-utils.js";
+/*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
+See https://js.arcgis.com/5.0/esri/copyright.txt for details.
+v5.0.0-next.100 */
+var M = Object.defineProperty, N = Object.getOwnPropertyDescriptor, d = (e, t, i, l) => {
+  for (var s = l > 1 ? void 0 : l ? N(t, i) : t, r = e.length - 1, o; r >= 0; r--)
+    (o = e[r]) && (s = (l ? o(t, i, s) : o(s)) || s);
+  return l && s && M(t, i, s), s;
+};
+let n = class extends m {
+  constructor(e) {
+    super(e), this.id = "root", this.children = new y(), this.layers = new y(), this.level = 0, this.childIds = /* @__PURE__ */ new Set(), this.layerUniqueIds = /* @__PURE__ */ new Set();
+  }
+  initialize() {
+    this.addHandles([
+      this.layers.on("before-add", (e) => {
+        this.layerUniqueIds.has(e.item.uid) ? e.preventDefault() : this.layerUniqueIds.add(e.item.uid);
+      }),
+      // Each time a layer is added/removed, we need to keep track of its visible
+      // and title properties because the node's properties depend on them.
+      this.layers.on("after-add", ({ item: e }) => {
+        this.addHandles(
+          [
+            b(
+              () => e.visible,
+              () => this.notifyChange("visible"),
+              { initial: !0 }
+            ),
+            b(
+              () => e.title,
+              () => this.notifyChange("title"),
+              { initial: !0 }
+            )
+          ],
+          e.uid
+        );
+      }),
+      this.layers.on("before-remove", ({ item: e }) => {
+        this.removeHandles(e.uid), this.notifyChange("title"), this.notifyChange("visible");
+      }),
+      this.children.on("before-add", (e) => {
+        this.childIds.has(e.item.id) ? e.preventDefault() : (e.item._set("parent", this), this.childIds.add(e.item.id));
+      })
+    ]);
+  }
+  destroy() {
+    this.children.forEach((e) => e.destroy());
+  }
+  get hasChildren() {
+    return this.children.length > 0;
+  }
+  get isDiscipline() {
+    return this.level === 1;
+  }
+  get visible() {
+    return f(this.layers, (e) => e.visible);
+  }
+  get title() {
+    return f(this.layers, (e) => e.title) || this.layers.map((e) => e.title).join(", ") || null;
+  }
+  /**
+   * Toggles the visibility of all the layers controlled by this node.
+   * If a value is specified, sets all the layers' visibility to that value.
+   *
+   * @param value
+   *    The value to which the `visible` property of each layer is to be set.
+   */
+  toggleVisibility(e) {
+    const t = e === void 0 ? !this.visible : e;
+    this.layers.forEach((i) => {
+      i.visible = t;
+    }), t && this.parent != null && this.parent.toggleVisibility(!0);
+  }
+  /**
+   * Toggles the visibility of all the layers controlled by this node,
+   * as well as setting the visibility of all the sibling's node of this node.
+   *
+   * @param value
+   *    The value to which the `visible` property of each layer and siblings is to be set.
+   */
+  toggleAllSiblingsVisibility(e) {
+    const t = e === void 0 ? !this.visible : e;
+    this.toggleVisibility(t), this.parent != null && (this.parent.toggleVisibility(t), this.parent.children.forEach((i) => i.toggleVisibility(t)));
+  }
+};
+d([
+  a({})
+], n.prototype, "id", 2);
+d([
+  a()
+], n.prototype, "parent", 2);
+d([
+  a({ readOnly: !0 })
+], n.prototype, "children", 2);
+d([
+  a({ readOnly: !0 })
+], n.prototype, "layers", 2);
+d([
+  a({})
+], n.prototype, "level", 2);
+d([
+  a({ readOnly: !0 })
+], n.prototype, "hasChildren", 1);
+d([
+  a({ readOnly: !0 })
+], n.prototype, "isDiscipline", 1);
+d([
+  a({ readOnly: !0 })
+], n.prototype, "visible", 1);
+d([
+  a({ readOnly: !0 })
+], n.prototype, "title", 1);
+n = d([
+  v("esri.widgets.BuildingExplorer.support.LayerTreeNode")
+], n);
+function f(e, t) {
+  let i = null;
+  for (const l of e) {
+    const s = t(l);
+    if (i != null && i !== s)
+      return null;
+    i = s;
+  }
+  return i;
+}
+var x = Object.defineProperty, P = Object.getOwnPropertyDescriptor, _ = (e) => {
+  throw TypeError(e);
+}, g = (e, t, i, l) => {
+  for (var s = l > 1 ? void 0 : l ? P(t, i) : t, r = e.length - 1, o; r >= 0; r--)
+    (o = e[r]) && (s = (l ? o(t, i, s) : o(s)) || s);
+  return l && s && x(t, i, s), s;
+}, F = (e, t, i) => t.has(e) || _("Cannot " + i), u = (e, t, i) => (F(e, t, "read from private field"), i ? i.call(e) : t.get(e)), T = (e, t, i) => t.has(e) ? _("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, i), c;
+let h = class extends m {
+  constructor(e) {
+    super(e), this.root = new n(), T(this, c, new y()), this.state = "disabled", this.loadLayers = O();
+  }
+  initialize() {
+    this.addHandles(
+      E(
+        () => this.layers,
+        "change",
+        () => void this._onLayersChange(),
+        {
+          onListenerAdd: () => void this._onLayersChange(),
+          onListenerRemove: () => void this._onLayersChange()
+        }
+      )
+    ), this._onLayersChange();
+  }
+  destroy() {
+    this._set("state", "disabled"), this.root.destroy();
+  }
+  get layers() {
+    return u(this, c);
+  }
+  set layers(e) {
+    u(this, c).removeAll(), u(this, c).addMany(e);
+  }
+  /**
+   * Initializes our internal tree with all the categories and disciplines from
+   * all the layers.
+   */
+  updateLayerTree() {
+    this.root.destroy(), this._set("root", new n());
+    const e = /* @__PURE__ */ new Map(), t = this.layers.length > 1 ? "modelName" : "id";
+    return this.layers.forEach((i) => {
+      const l = A(i);
+      this.addNodesForSublayers(l ?? i, this.root, e, t);
+    }), this;
+  }
+  /**
+   * Adds a node to control the specified layer. If a node already exists with
+   * the same `id` (i.e. same `modelName`), we simply add the layer to that node.
+   * This also recursively adds nodes for any sublayers.
+   *
+   * @param layer
+   *    The layer which is to be controlled by the node.
+   * @param parentNode
+   *    The node to which the new nodes are to be added.
+   * @param nodes
+   *    Map with all the nodes already added.
+   * @param matchBy
+   *    The sublayer property used to deduplicate sublayers.
+   */
+  addNodeForLayer(e, t, i, l) {
+    const s = String(e[l]).toLowerCase();
+    if (s == null || e.isEmpty)
+      return;
+    const r = `${t.id}/${s}`;
+    let o = i.get(r);
+    o || (o = new n({ id: s, level: t.level + 1 }), i.set(r, o)), o.layers.push(e), t.children.push(o), this.addNodesForSublayers(e, o, i, l);
+  }
+  /**
+   * Adds nodes for all the sublayers of the specified layer.
+   *
+   * @param layer
+   *    The layer whose sublayers are to be traversed.
+   * @param parentNode
+   *    The node to which new nodes are to be added.
+   * @param nodes
+   *    Map with all the nodes already added.
+   * @param matchBy
+   *    The sublayer property used to deduplicate sublayers.
+   */
+  addNodesForSublayers(e, t, i, l) {
+    (e.type === "building-scene" || e.type === "building-group" && !e.isEmpty) && e.sublayers.forEach((s) => this.addNodeForLayer(s, t, i, l));
+  }
+  /**
+   * Called when the layers are changed.
+   */
+  async _onLayersChange() {
+    if (this._set("state", "loading"), this.layers.length !== 0)
+      try {
+        await this.loadLayers(this.layers), this.updateLayerTree(), this._set("state", "ready");
+      } catch (e) {
+        D(e) || this._set("state", "failed");
+      }
+  }
+};
+c = /* @__PURE__ */ new WeakMap();
+g([
+  a()
+], h.prototype, "root", 2);
+g([
+  a()
+], h.prototype, "layers", 1);
+g([
+  a()
+], h.prototype, "state", 2);
+h = g([
+  v("esri.components.BuildingExplorer.BuildingDisciplinesViewModel")
+], h);
+const B = S`.label{--calcite-label-margin-bottom: 0}`;
+class I extends V {
+  constructor() {
+    super(...arguments), this.#e = new h(), this.toggleSiblingsVisibility = !1;
+  }
+  static {
+    this.properties = { layers: 0, messages: 0, toggleSiblingsVisibility: 5 };
+  }
+  static {
+    this.styles = B;
+  }
+  #e;
+  get layers() {
+    return this.#e.layers.toArray();
+  }
+  set layers(t) {
+    this.#e.layers = new y(t);
+  }
+  render() {
+    const t = this.messages, i = this.#e;
+    return t == null ? null : p`<calcite-tree lines selection-mode=none>${i.root.children.toArray().filter((l) => !l.isDiscipline || l.hasChildren).reverse().map((l) => w({ messages: t, node: l, toggleSiblingsVisibility: this.toggleSiblingsVisibility }))}${C({ node: i.root, messages: t })}</calcite-tree>`;
+  }
+}
+function w(e) {
+  const t = e.node, i = t.visible === !0, l = t.visible === null, s = i ? e.messages.hideSublayer : e.messages.showSublayer;
+  return p`<calcite-tree-item><calcite-label class="label" layout=inline><calcite-checkbox .checked=${i} .indeterminate=${l} .label=${s} @click=${(r) => {
+    r.stopPropagation(), (r.metaKey || r.ctrlKey) && e.toggleSiblingsVisibility && (t.toggleVisibility(), t.toggleAllSiblingsVisibility());
+  }} title=${s ?? $} @calciteCheckboxChange=${(r) => {
+    t.toggleVisibility(r.currentTarget.checked);
+  }}></calcite-checkbox>${e.node.title}</calcite-label>${e.node.hasChildren ? p`<calcite-tree lines selection-mode=none slot=children>${C({ node: e.node, messages: e.messages })}</calcite-tree>` : null}</calcite-tree-item>`;
+}
+function C(e) {
+  return e.node.children.toArray().reverse().map((i) => w({ node: i, messages: e.messages, toggleSiblingsVisibility: e.toggleSiblingsVisibility }));
+}
+L("arcgis-building-discipline-tree", I);
+export {
+  I as BuildingDisciplineTree
+};

package/dist/components/arcgis-building-discipline-tree/index.d.ts

@@ -0,0 +1,5 @@
+import "@esri/calcite-components/components/calcite-tree";
+import "@esri/calcite-components/components/calcite-tree-item";
+import "@esri/calcite-components/components/calcite-label";
+import "@esri/calcite-components/components/calcite-checkbox";
+export * from "./customElement.js";

package/dist/components/arcgis-building-discipline-tree/index.js

@@ -0,0 +1,5 @@
+import "@esri/calcite-components/components/calcite-tree";
+import "@esri/calcite-components/components/calcite-tree-item";
+import "@esri/calcite-components/components/calcite-label";
+import "@esri/calcite-components/components/calcite-checkbox";
+export * from "./customElement.js";

package/dist/components/arcgis-building-discipline-tree/layer-tree-node.d.ts

@@ -0,0 +1,80 @@
+import { default as Accessor } from '@arcgis/core/core/Accessor.js';
+import { default as Collection } from '@arcgis/core/core/Collection.js';
+import { default as BuildingSublayer } from '@arcgis/core/layers/buildingSublayers/BuildingSublayer';
+import { ConstructorProps } from '../../utils/types';
+type LayerTreeNodeProperties = ConstructorProps<LayerTreeNode, "id" | "layers" | "level" | "parent">;
+/**
+ * Node which controls any number of `BuildingSublayer`s so they can act as a
+ * single item in the `BuildingExplorer` "Disciplines & Categories" section.
+ */
+export declare class LayerTreeNode extends Accessor {
+    constructor(properties?: LayerTreeNodeProperties);
+    protected initialize(): void;
+    destroy(): void;
+    /**
+     * Identifier of this node.
+     */
+    readonly id: string;
+    /**
+     * Parent of this node in the `LayerTree`.
+     */
+    readonly parent?: LayerTreeNode;
+    /**
+     * The children of this node.
+     */
+    readonly children: Collection<LayerTreeNode>;
+    /**
+     * The layers which are being controlled by this node.
+     */
+    readonly layers: Collection<BuildingSublayer>;
+    /**
+     * The level in the hierarchy where this node is.
+     * This makes it easy to add indentation in the UI.
+     */
+    level: number;
+    /**
+     * Whether this node has children.
+     */
+    get hasChildren(): boolean;
+    /**
+     * Whether this node is a discipline, that is, a direct child of the root.
+     */
+    get isDiscipline(): boolean;
+    /**
+     * Gets the visibility of all the layers, if it is the same for all of
+     * them. Otherwise, returns null.
+     */
+    get visible(): nullish | boolean;
+    /**
+     * Gets the title of all the layers, if it is the same for all of them.
+     * Otherwise, returns null.
+     */
+    get title(): nullish | string;
+    /**
+     * Set which we use to check whether a certain child has already been added to
+     * the node.
+     */
+    private readonly childIds;
+    /**
+     * Set which we use to check whether a certain layer has already been added to
+     * the node.
+     */
+    private readonly layerUniqueIds;
+    /**
+     * Toggles the visibility of all the layers controlled by this node.
+     * If a value is specified, sets all the layers' visibility to that value.
+     *
+     * @param value
+     *    The value to which the `visible` property of each layer is to be set.
+     */
+    toggleVisibility(value?: boolean): void;
+    /**
+     * Toggles the visibility of all the layers controlled by this node,
+     * as well as setting the visibility of all the sibling's node of this node.
+     *
+     * @param value
+     *    The value to which the `visible` property of each layer and siblings is to be set.
+     */
+    toggleAllSiblingsVisibility(value?: boolean): void;
+}
+export {};

package/dist/components/arcgis-building-explorer/building-filter/BuildingFilterController.d.ts

@@ -0,0 +1,14 @@
+import { default as Accessor } from '@arcgis/core/core/Accessor.js';
+import { default as BuildingLevel } from './BuildingLevel';
+import { default as BuildingPhase } from './BuildingPhase';
+import { default as BuildingFilter } from '@arcgis/core/layers/support/BuildingFilter.js';
+import { default as Collection } from '@arcgis/core/core/Collection.js';
+import { default as BuildingSceneLayer } from '@arcgis/core/layers/BuildingSceneLayer';
+export default class BuildingFilterController extends Accessor {
+    private _layers?;
+    get layers(): Collection<BuildingSceneLayer> | undefined;
+    set layers(value: Collection<BuildingSceneLayer> | undefined);
+    readonly level: BuildingLevel;
+    readonly phase: BuildingPhase;
+    get filter(): BuildingFilter | nullish;
+}

package/dist/components/arcgis-building-explorer/building-filter/BuildingLevel.d.ts

@@ -0,0 +1,15 @@
+import { FilterExpressions, BuildingNumericFilterViewModelProperties, default as BuildingNumericFilterViewModel } from './BuildingNumericFilterViewModel';
+type BuildingLevelProperties = BuildingNumericFilterViewModelProperties;
+/**
+ * Provides information for the building level filter, such as
+ * the value selected by the user or the minimum and maximum allowed values.
+ */
+export default class BuildingLevel extends BuildingNumericFilterViewModel {
+    #private;
+    constructor(properties?: BuildingLevelProperties);
+    get filterExpressions(): FilterExpressions;
+    private _levelFieldName?;
+    get _firstValue(): number;
+    protected _setup(): void;
+}
+export {};

package/dist/components/arcgis-building-explorer/building-filter/BuildingNumericFilterViewModel.d.ts

@@ -0,0 +1,118 @@
+import { DomainInfo } from '../support/types';
+import { default as Accessor } from '@arcgis/core/core/Accessor.js';
+import { default as Collection } from '@arcgis/core/core/Collection.js';
+import { default as BuildingSceneLayer } from '@arcgis/core/layers/BuildingSceneLayer';
+import { ConstructorProps } from '../../../utils/types';
+type State = "disabled" | "failed" | "loading" | "ready";
+export type BuildingNumericFilterViewModelProperties = ConstructorProps<BuildingNumericFilterViewModel, "allowedValues" | "enabled" | "layers" | "state" | "value"> & {
+    isDefaultViewModel?: boolean;
+};
+/**
+ * Base class for the level filter and the construction phase filter
+ */
+export default abstract class BuildingNumericFilterViewModel extends Accessor {
+    #private;
+    constructor(properties?: BuildingNumericFilterViewModelProperties);
+    protected initialize(): void;
+    destroy(): void;
+    /**
+     * Whether the filter is enabled. If false, the filter's expression won't be
+     * used to filter a {@link module:esri/layers/BuildingSceneLayer}.
+     *
+     * @default false
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get value(): number;
+    set value(value: number);
+    /**
+     * The minimum value allowed for the filter.
+     */
+    get min(): nullish | number;
+    /**
+     * The maximum value allowed for the filter.
+     */
+    get max(): nullish | number;
+    get allowedValues(): readonly number[];
+    set allowedValues(value: nullish | readonly number[]);
+    /**
+     * Whether the next value can be selected.
+     */
+    get hasNext(): boolean;
+    /**
+     * Whether the previous value can be selected.
+     */
+    get hasPrevious(): boolean;
+    get layers(): Collection<BuildingSceneLayer>;
+    set layers(value: Collection<BuildingSceneLayer>);
+    private _state;
+    /**
+     * The current state of the view model.
+     */
+    get state(): State;
+    protected set state(value: State);
+    /**
+     * The expressions used to show only components which match this filter.
+     */
+    get filterExpressions(): FilterExpressions;
+    protected _valueBeforeReady?: number;
+    /**
+     * The index of the current value in the list of allowed values or -1 if the
+     * value could not be found (should never happen).
+     */
+    protected get _valueIndex(): number;
+    /**
+     * Map between values allowed for the filter and their respective names. This
+     * is essentially the source of truth for the VM, from which we can extract
+     * the allowed values, compute min/max, get the coded name of a value.
+     */
+    protected _domainInfo: DomainInfo;
+    /**
+     * Selects the specified value for the filter. In case the filter is disabled, this
+     * method also enables it by setting [enabled](#enabled) to `true`.
+     *
+     * @param value - The value which is to be selected.
+     */
+    select(value: number): void;
+    /**
+     * Removes the filter by setting [enabled](#enabled) to `false`.
+     */
+    clear(): void;
+    /**
+     * Selects the next value, if available. If [enabled](#enabled) is `false`,
+     * the first allowed value is selected.
+     */
+    next(): void;
+    /**
+     * Selects the previous value, if available. If [enabled](#enabled) is `false`,
+     * the last allowed value is selected.
+     */
+    previous(): void;
+    /**
+     * If the field that is used for filtering has a coded value domain, the label for the value can
+     * be used to be displayed in a tooltip or in the widget UI. This method returns the label
+     * corresponding to a certain value.
+     *
+     * @param value - A filter value.
+     * @return The label corresponding to the filter value.
+     */
+    getValueLabel(value: number): nullish | string;
+    /**
+     * Called after the layers have been loaded. Here subclasses should collect all
+     * the necessary domains and prepare a valid `DomainInfo`.
+     */
+    protected abstract _setup(): void;
+    private _loadLayers;
+    private _onLayersChange;
+}
+export interface FilterExpressions {
+    /**
+     * Expression used to filter components which should be rendered in solid mode.
+     */
+    solid: nullish | string;
+    /**
+     * Expression used to filter components which should be rendered in x-ray mode.
+     */
+    xRay: nullish | string;
+}
+export {};

package/dist/components/arcgis-building-explorer/building-filter/BuildingPhase.d.ts

@@ -0,0 +1,28 @@
+import { FilterExpressions, BuildingNumericFilterViewModelProperties, default as BuildingNumericFilterViewModel } from './BuildingNumericFilterViewModel';
+type BuildingPhaseProperties = BuildingNumericFilterViewModelProperties;
+/**
+ * BuildingPhase provides information for the construction phase filter, such as
+ * the value selected by the user or the minimum and maximum allowed values.
+ * Construction phases are used to track site development for a [`BuildingSceneLayer`](https://next.gha.afd.arcgis.com/javascript/latest/api-reference/esri-layers-BuildingSceneLayer.html).
+ * Setting a construction phase in the [`BuildingExplorer`](https://next.gha.afd.arcgis.com/javascript/latest/references/map-components/arcgis-building-explorer/) selects everything in the layer which is already constructed
+ * at that phase (created phase <= selected phase) but not yet demolished (demolished phase > selected phase).
+ * The goal is to display what the building or construction site looks like at that selected phase.
+ */
+export default class BuildingPhase extends BuildingNumericFilterViewModel {
+    constructor(properties?: BuildingPhaseProperties);
+    get filterExpressions(): FilterExpressions;
+    private _createdPhaseFieldName?;
+    private _demolishedPhaseFieldName?;
+    get _lastValue(): number;
+    protected _setup(): void;
+    /**
+     * Parses the `filterExpression`s in the specified filter to try and determine
+     * the phase used to create the filter. This value can then be used to restore
+     * the UI to the correct state.
+     *
+     * @param filter
+     *    The filter whose expressions are to be parsed.
+     */
+    private _parseValueFromFilter;
+}
+export {};