@arcgis/map-components 1.0.0-beta.14

package/dist/types/components/arcgis-feature-table/arcgis-feature-table.d.ts

@@ -0,0 +1,72 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type FeatureTable from "@arcgis/core/widgets/FeatureTable";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type FeatureTableWidget = InstanceType<typeof FeatureTable>;
+export declare class ArcgisFeatureTable implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  activeFilters: FeatureTableWidget["activeFilters"];
+  activeSortOrders: FeatureTableWidget["activeSortOrders"];
+  attachmentsEnabled: FeatureTableWidget["attachmentsEnabled"];
+  autoRefreshEnabled: FeatureTableWidget["autoRefreshEnabled"];
+  columnReorderingEnabled: FeatureTableWidget["columnReorderingEnabled"];
+  columns: FeatureTableWidget["columns"];
+  editingEnabled: FeatureTableWidget["editingEnabled"];
+  filterGeometry: FeatureTableWidget["filterGeometry"];
+  hiddenFields: FeatureTableWidget["hiddenFields"];
+  highlightEnabled: FeatureTableWidget["highlightEnabled"];
+  highlightIds: FeatureTableWidget["highlightIds"];
+  layer: FeatureTableWidget["layer"];
+  menu: FeatureTableWidget["menu"];
+  menuConfig: FeatureTableWidget["menuConfig"];
+  multiSortEnabled: FeatureTableWidget["multiSortEnabled"];
+  pageSize: FeatureTableWidget["pageSize"];
+  state: FeatureTableWidget["state"];
+  tableTemplate: FeatureTableWidget["tableTemplate"];
+  itemId: string;
+  position: string;
+  expandable: boolean;
+  url: string;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: FeatureTableWidget;
+  rowSelectionChange: EventEmitter<__esri.CollectionChangeEvent<number>>;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  attachmentsEnabledWatcher(value: FeatureTableWidget["attachmentsEnabled"]): void;
+  autoRefreshEnabledWatcher(value: FeatureTableWidget["autoRefreshEnabled"]): void;
+  columnReorderingEnabledWatcher(value: FeatureTableWidget["columnReorderingEnabled"]): void;
+  editingEnabledWatcher(value: FeatureTableWidget["editingEnabled"]): void;
+  filterGeometryWatcher(value: FeatureTableWidget["filterGeometry"]): void;
+  hiddenFieldsWatcher(value: FeatureTableWidget["hiddenFields"]): void;
+  highlightEnabledWatcher(value: FeatureTableWidget["highlightEnabled"]): void;
+  highlightIdsWatcher(value: FeatureTableWidget["highlightIds"]): void;
+  menuConfigWatcher(value: FeatureTableWidget["menuConfig"]): void;
+  multiSortEnabledWatcher(value: FeatureTableWidget["multiSortEnabled"]): void;
+  pageSizeWatcher(value: FeatureTableWidget["pageSize"]): void;
+  tableTemplateWatcher(value: FeatureTableWidget["tableTemplate"]): void;
+  itemIdWatcher(value: string, old: string): Promise<void>;
+  layerWatcher(value: FeatureTableWidget["layer"]): void;
+  urlWatcher(value: string, old: string): Promise<void>;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView): void;
+  clearSelectionFilter(): Promise<void>;
+  deleteSelection(showWarningPrompt?: boolean): Promise<void>;
+  filterBySelection(): Promise<void>;
+  findColumn(fieldName: string): Promise<__esri.Column | __esri.GroupColumn>;
+  hideColumn(fieldName: string): Promise<void>;
+  refresh(): Promise<void>;
+  scrollToIndex(index: number): Promise<void>;
+  showAllColumns(): Promise<void>;
+  showColumn(fieldName: string): Promise<void>;
+  sortColumn(path: string, direction: "asc" | "desc"): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-feature-templates/arcgis-feature-templates.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type FeatureTemplates from "@arcgis/core/widgets/FeatureTemplates";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISFeatureLayer } from "../types";
+export type FeatureTemplatesWidget = InstanceType<typeof FeatureTemplates>;
+export declare class ArcgisFeatureTemplates implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  position: string;
+  expandable: boolean;
+  widget: FeatureTemplatesWidget;
+  layers: ArcGISFeatureLayer[];
+  widgetReady: EventEmitter<boolean>;
+  layersWatcher(newValue: ArcGISFeatureLayer[]): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-features/arcgis-features.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Features from "@arcgis/core/widgets/Features";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type FeaturesWidget = InstanceType<typeof Features>;
+export declare class ArcgisFeatures {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  view: ArcGISMapView | ArcGISSceneView;
+  position: string;
+  expandable: boolean;
+  content: FeaturesWidget["content"];
+  features: FeaturesWidget["features"];
+  selectedFeature: FeaturesWidget["selectedFeature"];
+  selectedFeatureIndex: FeaturesWidget["selectedFeatureIndex"];
+  selectedFeatureWidget: FeaturesWidget["selectedFeatureWidget"];
+  widget: FeaturesWidget;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  fetchFeatures(screenPoint: __esri.FeaturesFetchFeaturesScreenPoint, options?: __esri.FetchFeaturesOptions): Promise<__esri.FetchPopupFeaturesResult>;
+  clear(): Promise<void>;
+  close(): Promise<void>;
+  next(): Promise<__esri.FeaturesViewModel>;
+  open(options?: __esri.FeaturesOpenOptions): Promise<void>;
+  previous(): Promise<__esri.FeaturesViewModel>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+}

package/dist/types/components/arcgis-floor-filter/arcgis-floor-filter.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type FloorFilter from "@arcgis/core/widgets/FloorFilter";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type FloorFilterWidget = InstanceType<typeof FloorFilter>;
+export declare class ArcgisFloorFilter implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  facility: FloorFilterWidget["facility"];
+  level: FloorFilterWidget["level"];
+  longNames: FloorFilterWidget["longNames"];
+  site: FloorFilterWidget["site"];
+  position: string;
+  expandable: boolean;
+  widget: FloorFilterWidget;
+  view: ArcGISMapView | ArcGISSceneView;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  facilityWatcher(newValue: FloorFilterWidget["facility"]): void;
+  levelWatcher(newValue: FloorFilterWidget["level"]): void;
+  longNamesWatcher(newValue: FloorFilterWidget["longNames"]): void;
+  siteWatcher(newValue: FloorFilterWidget["site"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  updateWebDocument(webmap: __esri.WebMap): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-fullscreen/arcgis-fullscreen.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Fullscreen from "@arcgis/core/widgets/Fullscreen";
+import { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type FullscreenWidget = InstanceType<typeof Fullscreen>;
+export declare class ArcgisFullscreen implements WidgetElement {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  referenceElement: ArcgisReferenceElement | string;
+  element: FullscreenWidget["element"];
+  position: string;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: FullscreenWidget;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  elementWatcher(newValue: FullscreenWidget["element"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-histogram/arcgis-histogram.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import type Histogram from "@arcgis/core/widgets/Histogram";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+export type HistogramWidget = InstanceType<typeof Histogram>;
+export declare class ArcgisHistogram implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  position: string;
+  expandable: boolean;
+  widget: HistogramWidget;
+  widgetReady: EventEmitter<boolean>;
+  componentDidLoad(): Promise<void>;
+}

package/dist/types/components/arcgis-histogram-range-slider/arcgis-histogram-range-slider.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type HistogramRangeSlider from "@arcgis/core/widgets/HistogramRangeSlider";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+export type HistogramRangeSliderWidget = InstanceType<typeof HistogramRangeSlider>;
+export declare class ArcgisHistogramRangeSlider implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  max: number;
+  min: number;
+  position: string;
+  expandable: boolean;
+  widget: HistogramRangeSliderWidget;
+  widgetReady: EventEmitter<boolean>;
+  maxWatcher(newValue: number): void;
+  minWatcher(newValue: number): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-home/arcgis-home.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Home from "@arcgis/core/widgets/Home";
+import { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type HomeWidget = InstanceType<typeof Home>;
+export declare class ArcgisHome implements WidgetElement {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  referenceElement: ArcgisReferenceElement | string;
+  viewpoint: HomeWidget["viewpoint"];
+  view: ArcGISMapView | ArcGISSceneView;
+  position: string;
+  widget: HomeWidget;
+  goCalled: EventEmitter<__esri.HomeGoEvent>;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  viewpointWatcher(newValue: HomeWidget["viewpoint"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  cancelGo(): Promise<void>;
+  go(): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-layer-list/arcgis-layer-list.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type LayerList from "@arcgis/core/widgets/LayerList";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type LayerListWidget = InstanceType<typeof LayerList>;
+export declare class ArcgisLayerList implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  multipleSelectionEnabled: LayerListWidget["multipleSelectionEnabled"];
+  operationalItems: LayerListWidget["operationalItems"];
+  selectedItems: LayerListWidget["selectedItems"];
+  selectionEnabled: LayerListWidget["selectionEnabled"];
+  position: string;
+  expandable: boolean;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: LayerListWidget;
+  triggerActionEvent: EventEmitter<__esri.LayerListTriggerActionEvent>;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  multipleSelectionEnabledWatcher(newValue: LayerListWidget["multipleSelectionEnabled"]): void;
+  selectedItemsWatcher(newValue: LayerListWidget["selectedItems"]): void;
+  selectionEnabledWatcher(newValue: LayerListWidget["selectionEnabled"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  triggerAction(action: __esri.ActionButton | __esri.ActionToggle, item: __esri.ListItem): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-legend/arcgis-legend.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Legend from "@arcgis/core/widgets/Legend";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type LegendWidget = InstanceType<typeof Legend>;
+export declare class ArcgisLegend implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  activeLayerInfos: LegendWidget["activeLayerInfos"];
+  basemapLegendVisible: LegendWidget["basemapLegendVisible"];
+  hideLayersNotInCurrentView: LegendWidget["hideLayersNotInCurrentView"];
+  layerInfos: LegendWidget["layerInfos"];
+  respectLayerVisibility: LegendWidget["respectLayerVisibility"];
+  legendStyle: LegendWidget["style"];
+  position: string;
+  expandable: boolean;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: LegendWidget;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  activeLayerInfosWatcher(newValue: LegendWidget["activeLayerInfos"]): void;
+  basemapLegendVisibleWatcher(newValue: LegendWidget["basemapLegendVisible"]): void;
+  hideLayersNotInCurrentViewWatcher(newValue: LegendWidget["hideLayersNotInCurrentView"]): void;
+  layerInfosWatcher(newValue: LegendWidget["layerInfos"]): void;
+  respectLayerVisibilityWatcher(newValue: LegendWidget["respectLayerVisibility"]): void;
+  styleWatcher(newValue: LegendWidget["style"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-line-of-sight/arcgis-line-of-sight.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type LineOfSight from "@arcgis/core/widgets/LineOfSight";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISSceneView } from "../types";
+export type LineOfSightWidget = InstanceType<typeof LineOfSight>;
+export declare class ArcgisLineOfSight implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  analysis: LineOfSightWidget["analysis"];
+  position: string;
+  expandable: boolean;
+  view: ArcGISSceneView;
+  widget: LineOfSightWidget;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISSceneView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+}

package/dist/types/components/arcgis-locate/arcgis-locate.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Locate from "@arcgis/core/widgets/Locate";
+import { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type LocateWidget = InstanceType<typeof Locate>;
+export declare class ArcgisLocate implements WidgetElement {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  referenceElement: ArcgisReferenceElement | string;
+  geolocationOptions: LocateWidget["geolocationOptions"];
+  goToLocationEnabled: LocateWidget["goToLocationEnabled"];
+  graphic: LocateWidget["graphic"];
+  popupEnabled: LocateWidget["popupEnabled"];
+  scale: LocateWidget["scale"];
+  position: string;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: LocateWidget;
+  useHeadingEnabled: LocateWidget["useHeadingEnabled"];
+  widgetReady: EventEmitter<boolean>;
+  locateSuccess: EventEmitter<__esri.LocateLocateEvent>;
+  locateError: EventEmitter<__esri.LocateLocateErrorEvent>;
+  positionWatcher(newValue: string): void;
+  geolocationOptionsWatcher(newValue: LocateWidget["geolocationOptions"]): void;
+  goToLocationEnabledWatcher(newValue: LocateWidget["goToLocationEnabled"]): void;
+  graphicWatcher(newValue: LocateWidget["graphic"]): void;
+  popupEnabledWatcher(newValue: LocateWidget["popupEnabled"]): void;
+  scaleWatcher(newValue: LocateWidget["scale"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  useHeadingWatcher(newValue: boolean): void;
+  cancelLocate(): Promise<void>;
+  locate(): Promise<any>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-map/arcgis-map.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { ViewElement } from "../../utils/component-utils";
+import { ArcGISMapView } from "../types";
+export declare class ArcgisMap implements ViewElement {
+  el: HTMLDivElement;
+  hostElem: HTMLElement;
+  apiKey: string;
+  basemap: string;
+  disableNavigation: boolean;
+  itemId: string;
+  zoom: number;
+  center: number[] | string;
+  view: ArcGISMapView;
+  viewReady: EventEmitter<boolean>;
+  config: __esri.config;
+  apiKeyWatcher(value: string): void;
+  itemIdWatcher(value: string, old: string): void;
+  componentWillLoad(): Promise<void>;
+  componentDidRender(): void;
+  render(): VNode;
+  loadMap(): Promise<void>;
+}

package/dist/types/components/arcgis-measurement/arcgis-measurement.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Measurement from "@arcgis/core/widgets/Measurement";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type MeasurementWidget = InstanceType<typeof Measurement>;
+export declare class ArcgisMeasurement implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  activeTool: MeasurementWidget["activeTool"];
+  activeWidget: MeasurementWidget["activeWidget"];
+  areaUnit: MeasurementWidget["areaUnit"];
+  linearUnit: MeasurementWidget["linearUnit"];
+  position: string;
+  expandable: boolean;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: MeasurementWidget;
+  widgetReady: EventEmitter<boolean>;
+  activeToolWatcher(newValue: MeasurementWidget["activeTool"]): void;
+  areaUnitWatcher(newValue: MeasurementWidget["areaUnit"]): void;
+  linearUnitWatcher(newValue: MeasurementWidget["linearUnit"]): void;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  startMeasurement(): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+}

package/dist/types/components/arcgis-navigation-toggle/arcgis-navigation-toggle.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type NavigationToggle from "@arcgis/core/widgets/NavigationToggle";
+import { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import { ArcGISSceneView } from "../types";
+export type NavigationToggleWidget = InstanceType<typeof NavigationToggle>;
+export declare class ArcgisNavigationToggle implements WidgetElement {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  referenceElement: ArcgisReferenceElement | string;
+  layout: NavigationToggleWidget["layout"];
+  position: string;
+  view: ArcGISSceneView;
+  widget: NavigationToggleWidget;
+  widgetReady: EventEmitter<boolean>;
+  layoutWatcher(newValue: NavigationToggleWidget["layout"]): void;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISSceneView): void;
+  toggle(): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-print/arcgis-print.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Print from "@arcgis/core/widgets/Print";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView } from "../types";
+export type PrintWidget = InstanceType<typeof Print>;
+export declare class ArcgisPrint implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  allowedFormats: PrintWidget["allowedFormats"];
+  allowedLayouts: PrintWidget["allowedLayouts"];
+  exportedLinks: PrintWidget["exportedLinks"];
+  extraParameters: PrintWidget["extraParameters"];
+  includeDefaultTemplates: PrintWidget["includeDefaultTemplates"];
+  portal: PrintWidget["portal"];
+  printServiceUrl: PrintWidget["printServiceUrl"];
+  templateCustomTextElements: PrintWidget["templateCustomTextElements"];
+  templateOptions: PrintWidget["templateOptions"];
+  position: string;
+  expandable: boolean;
+  view: ArcGISMapView;
+  widget: PrintWidget;
+  printComplete: EventEmitter<__esri.PrintCompleteEvent>;
+  printSubmit: EventEmitter<__esri.PrintSubmitEvent>;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  allowedFormatsWatcher(value: string): void;
+  allowedLayoutsWatcher(value: string): void;
+  extraParametersWatcher(value: PrintWidget["extraParameters"]): void;
+  includeDefaultTemplatesWatcher(value: PrintWidget["includeDefaultTemplates"]): void;
+  portalWatcher(value: PrintWidget["portal"]): void;
+  printServiceUrlWatcher(value: PrintWidget["printServiceUrl"]): void;
+  templateCustomTextElementsWatcher(value: PrintWidget["templateCustomTextElements"]): void;
+  templateOptionsWatcher(value: PrintWidget["templateOptions"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-scale-bar/arcgis-scale-bar.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type ScaleBar from "@arcgis/core/widgets/ScaleBar";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView } from "../types";
+export type ScaleBarWidget = InstanceType<typeof ScaleBar>;
+export declare class ArcgisScaleBar implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  view: ArcGISMapView;
+  position: string;
+  expandable: boolean;
+  barStyle: ScaleBarWidget["style"];
+  unit: ScaleBarWidget["unit"];
+  widget: ScaleBarWidget;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView): void;
+  styleWatcher(newValue: ScaleBarWidget["style"]): void;
+  unitWatcher(newValue: ScaleBarWidget["unit"]): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-scale-range-slider/arcgis-scale-range-slider.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Layer from "@arcgis/core/layers/Layer";
+import type ScaleRangeSlider from "@arcgis/core/widgets/ScaleRangeSlider";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type ScaleRangeSliderWidget = InstanceType<typeof ScaleRangeSlider>;
+export type ArcGISLayer = InstanceType<typeof Layer>;
+export declare class ArcgisScaleRangeSlider implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  view: ArcGISMapView | ArcGISSceneView;
+  position: string;
+  expandable: boolean;
+  widget: ScaleRangeSliderWidget;
+  layer: ScaleRangeSliderWidget["layer"];
+  maxScale: ScaleRangeSliderWidget["maxScale"];
+  maxScaleLimit: ScaleRangeSliderWidget["maxScaleLimit"];
+  minScale: ScaleRangeSliderWidget["minScale"];
+  minScaleLimit: ScaleRangeSliderWidget["minScaleLimit"];
+  region: ScaleRangeSliderWidget["region"];
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  maxScaleWatcher(newValue: ScaleRangeSliderWidget["maxScale"]): void;
+  minScaleWatcher(newValue: ScaleRangeSliderWidget["minScale"]): void;
+  maxScaleLimitWatcher(newValue: ScaleRangeSliderWidget["maxScaleLimit"]): void;
+  minScaleLimitWatcher(newValue: ScaleRangeSliderWidget["minScaleLimit"]): void;
+  layerWatcher(newValue: ScaleRangeSliderWidget["layer"]): void;
+  regionWatcher(newValue: ScaleRangeSliderWidget["region"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

package/dist/types/components/arcgis-scene/arcgis-scene.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { ViewElement } from "../../utils/component-utils";
+import { ArcGISSceneView } from "../types";
+export declare class ArcgisScene implements ViewElement {
+  el: HTMLDivElement;
+  hostElem: HTMLElement;
+  apiKey: string;
+  itemId: string;
+  zoom: number;
+  center: number[] | string;
+  view: ArcGISSceneView;
+  disableNavigation: boolean;
+  config: __esri.config;
+  apiKeyWatcher(value: string): void;
+  itemIdWatcher(value: string, old: string): void;
+  viewReady: EventEmitter<boolean>;
+  componentWillLoad(): Promise<void>;
+  componentDidRender(): void;
+  render(): VNode;
+  loadMap(): Promise<void>;
+}