@arcgis/map-components 1.0.0-beta.14

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

@@ -0,0 +1,80 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Search from "@arcgis/core/widgets/Search";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type SearchWidget = InstanceType<typeof Search>;
+export declare class ArcgisSearch implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  activeMenu: SearchWidget["activeMenu"];
+  activeSource: SearchWidget["activeSource"];
+  activeSourceIndex: SearchWidget["activeSourceIndex"];
+  allPlaceholder: SearchWidget["allPlaceholder"];
+  allSources: SearchWidget["allSources"];
+  autoSelect: SearchWidget["autoSelect"];
+  defaultSources: SearchWidget["defaultSources"];
+  includeDefaultSources: SearchWidget["includeDefaultSources"];
+  locationEnabled: SearchWidget["locationEnabled"];
+  maxResults: SearchWidget["maxResults"];
+  maxSuggestions: SearchWidget["maxSuggestions"];
+  minSuggestCharacters: SearchWidget["minSuggestCharacters"];
+  popupEnabled: SearchWidget["popupEnabled"];
+  popupTemplate: SearchWidget["popupTemplate"];
+  portal: SearchWidget["portal"];
+  resultGraphic: SearchWidget["resultGraphic"];
+  resultGraphicEnabled: SearchWidget["resultGraphicEnabled"];
+  results: SearchWidget["results"];
+  searchAllEnabled: SearchWidget["searchAllEnabled"];
+  searchTerm: SearchWidget["searchTerm"];
+  selectedResult: SearchWidget["selectedResult"];
+  sources: SearchWidget["sources"];
+  suggestions: SearchWidget["suggestions"];
+  suggestionsEnabled: SearchWidget["suggestionsEnabled"];
+  position: string;
+  expandable: boolean;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: SearchWidget;
+  widgetReady: EventEmitter<boolean>;
+  searchBlur: EventEmitter<__esri.SearchSearchBlurEvent>;
+  searchClear: EventEmitter<__esri.SearchSearchClearEvent>;
+  searchComplete: EventEmitter<__esri.SearchSearchCompleteEvent>;
+  searchFocus: EventEmitter<__esri.SearchSearchFocusEvent>;
+  searchStart: EventEmitter<__esri.SearchSearchStartEvent>;
+  selectResult: EventEmitter<__esri.SearchSelectResultEvent>;
+  suggestComplete: EventEmitter<__esri.SearchSuggestCompleteEvent>;
+  suggestStart: EventEmitter<__esri.SearchSuggestStartEvent>;
+  positionWatcher(newValue: string): void;
+  activeMenuWatcher(newValue: SearchWidget["activeMenu"]): void;
+  activeSourceIndexWatcher(newValue: SearchWidget["activeSourceIndex"]): void;
+  allPlaceholderWatcher(newValue: SearchWidget["allPlaceholder"]): void;
+  autoSelectWatcher(newValue: SearchWidget["autoSelect"]): void;
+  includeDefaultSourcesWatcher(newValue: SearchWidget["includeDefaultSources"]): void;
+  locationEnabledWatcher(newValue: SearchWidget["locationEnabled"]): void;
+  maxResultsWatcher(newValue: SearchWidget["maxResults"]): void;
+  maxSuggestionsWatcher(newValue: SearchWidget["maxSuggestions"]): void;
+  minSuggestCharactersWatcher(newValue: SearchWidget["minSuggestCharacters"]): void;
+  popupEnabledWatcher(newValue: SearchWidget["popupEnabled"]): void;
+  popupTemplateWatcher(newValue: SearchWidget["popupTemplate"]): void;
+  portalWatcher(newValue: SearchWidget["portal"]): void;
+  resultGraphicEnabledWatcher(newValue: SearchWidget["resultGraphicEnabled"]): void;
+  searchAllEnabledWatcher(newValue: SearchWidget["searchAllEnabled"]): void;
+  searchTermWatcher(newValue: SearchWidget["searchTerm"]): void;
+  sourcesWatcher(newValue: SearchWidget["sources"]): void;
+  suggestionsEnabledWatcher(newValue: SearchWidget["suggestionsEnabled"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  blurSearch(): Promise<void>;
+  clearSearch(): Promise<void>;
+  focusSearch(): Promise<void>;
+  search(term: string | __esri.Geometry | __esri.SuggestResult | number[][]): Promise<__esri.SearchResponse>;
+  suggest(term: string): Promise<__esri.SuggestResponse>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-shadow-cast/arcgis-shadow-cast.d.ts

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

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

@@ -0,0 +1,51 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Sketch from "@arcgis/core/widgets/Sketch";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type SketchWidget = InstanceType<typeof Sketch>;
+export declare class ArcgisSketch implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  activeTool: SketchWidget["activeTool"];
+  availableCreateTools: SketchWidget["availableCreateTools"];
+  createGraphic: SketchWidget["createGraphic"];
+  creationMode: SketchWidget["creationMode"];
+  defaultCreateOptions: SketchWidget["defaultCreateOptions"];
+  defaultUpdateOptions: SketchWidget["defaultUpdateOptions"];
+  labelOptions: SketchWidget["labelOptions"];
+  layer: SketchWidget["layer"];
+  layout: SketchWidget["layout"];
+  snappingOptions: SketchWidget["snappingOptions"];
+  tooltipOptions: SketchWidget["tooltipOptions"];
+  updateGraphics: SketchWidget["updateGraphics"];
+  view: ArcGISMapView | ArcGISSceneView;
+  position: string;
+  expandable: boolean;
+  widget: SketchWidget;
+  sketchCreate: EventEmitter<__esri.SketchCreateEvent>;
+  sketchDelete: EventEmitter<__esri.SketchDeleteEvent>;
+  sketchRedo: EventEmitter<__esri.SketchRedoEvent>;
+  sketchUndo: EventEmitter<__esri.SketchUndoEvent>;
+  sketchUpdate: EventEmitter<__esri.SketchUpdateEvent>;
+  widgetReady: EventEmitter<boolean>;
+  availableCreateToolsWatcher(newValue: SketchWidget["availableCreateTools"]): void;
+  creationModeWatcher(newValue: SketchWidget["creationMode"]): void;
+  defaultCreateOptionsWatcher(newValue: SketchWidget["defaultCreateOptions"]): void;
+  defaultUpdateOptionsWatcher(newValue: SketchWidget["defaultUpdateOptions"]): void;
+  labelOptionsWatcher(newValue: SketchWidget["labelOptions"]): void;
+  layerWatcher(newValue: SketchWidget["layer"]): void;
+  layoutWatcher(newValue: SketchWidget["layout"]): void;
+  snappingOptionsWatcher(newValue: SketchWidget["snappingOptions"]): void;
+  tooltipOptionsWatcher(newValue: SketchWidget["tooltipOptions"]): void;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+}

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

@@ -0,0 +1,28 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import Slice from "@arcgis/core/widgets/Slice";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISSceneView } from "../types";
+export type SliceWidget = InstanceType<typeof Slice>;
+export declare class ArcgisSlice implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  analysis: SliceWidget["analysis"];
+  view: ArcGISSceneView;
+  position: string;
+  expandable: boolean;
+  widget: SliceWidget;
+  headingLevel: number;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  headingLevelWatcher(newValue: number): 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-slider/arcgis-slider.d.ts

@@ -0,0 +1,69 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Slider from "@arcgis/core/widgets/Slider";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+export type SliderWidget = InstanceType<typeof Slider>;
+export declare class ArcgisSlider implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  draggableSegmentsEnabled: SliderWidget["draggableSegmentsEnabled"];
+  effectiveMax: SliderWidget["effectiveMax"];
+  effectiveMin: SliderWidget["effectiveMin"];
+  effectiveSegmentElements: SliderWidget["effectiveSegmentElements"];
+  labelElements: SliderWidget["labelElements"];
+  labelInputsEnabled: SliderWidget["labelInputsEnabled"];
+  labels: SliderWidget["labels"];
+  layout: SliderWidget["layout"];
+  min: SliderWidget["min"];
+  max: SliderWidget["max"];
+  maxLabelElement: SliderWidget["maxLabelElement"];
+  minLabelElement: SliderWidget["minLabelElement"];
+  precision: SliderWidget["precision"];
+  rangeLabelInputsEnabled: SliderWidget["rangeLabelInputsEnabled"];
+  segmentElements: SliderWidget["segmentElements"];
+  snapOnClickEnabled: SliderWidget["snapOnClickEnabled"];
+  syncedSegmentsEnabled: SliderWidget["syncedSegmentsEnabled"];
+  thumbElements: SliderWidget["thumbElements"];
+  thumbsConstrained: SliderWidget["thumbsConstrained"];
+  tickConfigs: SliderWidget["tickConfigs"];
+  tickElements: SliderWidget["tickElements"];
+  trackElement: SliderWidget["trackElement"];
+  steps: SliderWidget["steps"] | string;
+  values: SliderWidget["values"] | string;
+  position: string;
+  expandable: boolean;
+  widget: SliderWidget;
+  sliderMaxChange: EventEmitter<__esri.SliderMaxChangeEvent>;
+  sliderMaxClick: EventEmitter<__esri.SliderMaxClickEvent>;
+  sliderMinChange: EventEmitter<__esri.SliderMinChangeEvent>;
+  sliderMinClick: EventEmitter<__esri.SliderMinClickEvent>;
+  sliderSegmentClick: EventEmitter<__esri.SliderSegmentClickEvent>;
+  sliderSegmentDrag: EventEmitter<__esri.SliderSegmentDragEvent>;
+  sliderThumbChange: EventEmitter<__esri.SliderThumbChangeEvent>;
+  sliderThumbClick: EventEmitter<__esri.SliderThumbClickEvent>;
+  sliderThumbDrag: EventEmitter<__esri.SliderThumbDragEvent>;
+  sliderTickClick: EventEmitter<__esri.SliderTickClickEvent>;
+  sliderTrackClick: EventEmitter<__esri.SliderTrackClickEvent>;
+  widgetReady: EventEmitter<boolean>;
+  draggableSegmentsEnabledWatcher(newValue: SliderWidget["draggableSegmentsEnabled"]): void;
+  effectiveMaxWatcher(newValue: SliderWidget["effectiveMax"]): void;
+  effectiveMinWatcher(newValue: SliderWidget["effectiveMin"]): void;
+  layoutWatcher(newValue: SliderWidget["layout"]): void;
+  minWatcher(newValue: SliderWidget["min"]): void;
+  maxWatcher(newValue: SliderWidget["max"]): void;
+  precisionWatcher(newValue: SliderWidget["precision"]): void;
+  rangeLabelInputsEnabledWatcher(newValue: SliderWidget["rangeLabelInputsEnabled"]): void;
+  snapOnClickEnabledWatcher(newValue: SliderWidget["snapOnClickEnabled"]): void;
+  stepsWatcher(newValue: SliderWidget["steps"]): void;
+  syncedSegmentsEnabledWatcher(newValue: SliderWidget["syncedSegmentsEnabled"]): void;
+  thumbsConstrainedWatcher(newValue: SliderWidget["thumbsConstrained"]): void;
+  tickConfigsWatcher(newValue: SliderWidget["tickConfigs"]): void;
+  valuesWatcher(newValue: SliderWidget["values"] | string): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+}

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

@@ -0,0 +1,31 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Swipe from "@arcgis/core/widgets/Swipe";
+import { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import { ArcGISMapView } from "../types";
+export type SwipeWidget = InstanceType<typeof Swipe>;
+export declare class ArcgisSwipe implements WidgetElement {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  referenceElement: ArcgisReferenceElement | string;
+  direction: SwipeWidget["direction"];
+  dragLabel: SwipeWidget["dragLabel"];
+  leadingLayers: SwipeWidget["leadingLayers"];
+  swipePosition: SwipeWidget["position"];
+  trailingLayers: SwipeWidget["trailingLayers"];
+  view: ArcGISMapView;
+  position: string;
+  widget: SwipeWidget;
+  widgetReady: EventEmitter<boolean>;
+  directionWatcher(newValue: SwipeWidget["direction"]): void;
+  dragLabelWatcher(newValue: SwipeWidget["dragLabel"]): void;
+  leadingLayersWatcher(newValue: SwipeWidget["leadingLayers"]): void;
+  swipePositionWatcher(newValue: SwipeWidget["position"]): void;
+  trailingLayersWatcher(newValue: SwipeWidget["trailingLayers"]): void;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+}

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

@@ -0,0 +1,33 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type TableList from "@arcgis/core/widgets/TableList";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type TableListWidget = InstanceType<typeof TableList>;
+export declare class ArcgisTableList implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  multipleSelectionEnabled: TableListWidget["multipleSelectionEnabled"];
+  selectionEnabled: TableListWidget["selectionEnabled"];
+  selectedItems: TableListWidget["selectedItems"];
+  tableItems: TableListWidget["tableItems"];
+  view: ArcGISMapView | ArcGISSceneView;
+  position: string;
+  expandable: boolean;
+  widget: TableListWidget;
+  triggerAction: EventEmitter<__esri.TableListTriggerActionEvent>;
+  widgetReady: EventEmitter<boolean>;
+  multipleSelectionEnabledWatcher(newValue: TableListWidget["multipleSelectionEnabled"]): void;
+  selectionEnabledWatcher(newValue: TableListWidget["selectionEnabled"]): void;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _hookEvents;
+}

package/dist/types/components/arcgis-time-slider/arcgis-time-slider.d.ts

@@ -0,0 +1,52 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type TimeSlider from "@arcgis/core/widgets/TimeSlider";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type TimeSliderWidget = InstanceType<typeof TimeSlider>;
+export declare class ArcgisTimeSlider implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  actions: TimeSliderWidget["actions"];
+  effectiveStops: TimeSliderWidget["effectiveStops"];
+  fullTimeExtent: TimeSliderWidget["fullTimeExtent"];
+  layout: TimeSliderWidget["layout"];
+  loop: TimeSliderWidget["loop"];
+  mode: TimeSliderWidget["mode"];
+  playRate: TimeSliderWidget["playRate"];
+  stops: TimeSliderWidget["stops"];
+  tickConfigs: TimeSliderWidget["tickConfigs"];
+  timeExtent: TimeSliderWidget["timeExtent"];
+  timeVisible: TimeSliderWidget["timeVisible"];
+  view: ArcGISMapView | ArcGISSceneView;
+  position: string;
+  expandable: boolean;
+  widget: TimeSliderWidget;
+  triggerAction: EventEmitter<__esri.TimeSliderTriggerActionEvent>;
+  widgetReady: EventEmitter<boolean>;
+  actionsWatcher(newValue: TimeSliderWidget["actions"]): void;
+  fullTimeExtentWatcher(newValue: TimeSliderWidget["fullTimeExtent"]): void;
+  layoutWatcher(newValue: TimeSliderWidget["layout"]): void;
+  loopWatcher(newValue: TimeSliderWidget["loop"]): void;
+  modeWatcher(newValue: TimeSliderWidget["mode"]): void;
+  playRateWatcher(newValue: TimeSliderWidget["playRate"]): void;
+  stopsWatcher(newValue: TimeSliderWidget["stops"]): void;
+  tickConfigsWatcher(newValue: TimeSliderWidget["tickConfigs"]): void;
+  timeExtentWatcher(newValue: TimeSliderWidget["timeExtent"]): void;
+  timeVisibleWatcher(newValue: TimeSliderWidget["timeVisible"]): void;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  next(): Promise<void>;
+  play(): Promise<void>;
+  previous(): Promise<void>;
+  stop(): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _proxyEvents;
+}

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

@@ -0,0 +1,36 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Track from "@arcgis/core/widgets/Track";
+import { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type TrackWidget = InstanceType<typeof Track>;
+export declare class ArcgisTrack implements WidgetElement {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  referenceElement: ArcgisReferenceElement | string;
+  geolocationOptions: TrackWidget["geolocationOptions"];
+  goToLocationEnabled: TrackWidget["goToLocationEnabled"];
+  graphic: TrackWidget["graphic"];
+  scale: TrackWidget["scale"];
+  tracking: TrackWidget["tracking"];
+  useHeadingEnabled: TrackWidget["useHeadingEnabled"];
+  position: string;
+  view: ArcGISMapView | ArcGISSceneView;
+  widget: TrackWidget;
+  trackComplete: EventEmitter<__esri.TrackTrackEvent>;
+  trackError: EventEmitter<__esri.TrackTrackErrorEvent>;
+  widgetReady: EventEmitter<boolean>;
+  positionWatcher(newValue: string): void;
+  geolocationOptionsWatcher(newValue: TrackWidget["geolocationOptions"]): void;
+  goToLocationEnabledWatcher(newValue: TrackWidget["goToLocationEnabled"]): void;
+  graphicWatcher(newValue: TrackWidget["graphic"]): void;
+  scaleWatcher(newValue: TrackWidget["scale"]): void;
+  useHeadingEnabledWatcher(newValue: TrackWidget["useHeadingEnabled"]): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-utility-network-trace/arcgis-utility-network-trace.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type UtilityNetworkTrace from "@arcgis/core/widgets/UtilityNetworkTrace";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ExpandableComponent } from "../../utils/expandable";
+import { ArcGISMapView } from "../types";
+export type UtilityNetworkTraceWidget = InstanceType<typeof UtilityNetworkTrace>;
+export declare class ArcgisUtilityNetworkTrace implements ExpandableComponent {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  defaultGraphicColor: UtilityNetworkTraceWidget["defaultGraphicColor"];
+  flags: UtilityNetworkTraceWidget["flags"];
+  gdbVersion: UtilityNetworkTraceWidget["gdbVersion"];
+  inputSettings: UtilityNetworkTraceWidget["inputSettings"];
+  selectedTraces: UtilityNetworkTraceWidget["selectedTraces"];
+  selectOnComplete: UtilityNetworkTraceWidget["selectOnComplete"];
+  showGraphicsOnComplete: UtilityNetworkTraceWidget["showGraphicsOnComplete"];
+  showSelectionAttributes: UtilityNetworkTraceWidget["showSelectionAttributes"];
+  position: string;
+  expandable: boolean;
+  view: ArcGISMapView;
+  widget: UtilityNetworkTraceWidget;
+  traceAddFlag: EventEmitter<__esri.UtilityNetworkTraceAddFlagEvent>;
+  traceAddFlagComplete: EventEmitter<__esri.UtilityNetworkTraceAddFlagCompleteEvent>;
+  traceAddFlagError: EventEmitter<__esri.UtilityNetworkTraceAddFlagErrorEvent>;
+  widgetReady: EventEmitter<boolean>;
+  defaultGraphicColorWatcher(newValue: UtilityNetworkTraceWidget["defaultGraphicColor"]): void;
+  flagsWatcher(newValue: UtilityNetworkTraceWidget["flags"]): void;
+  gdbVersionWatcher(newValue: UtilityNetworkTraceWidget["gdbVersion"]): void;
+  inputSettingsWatcher(newValue: UtilityNetworkTraceWidget["inputSettings"]): void;
+  selectedTracesWatcher(newValue: UtilityNetworkTraceWidget["selectedTraces"]): void;
+  selectOnCompleteWatcher(newValue: UtilityNetworkTraceWidget["selectOnComplete"]): void;
+  showGraphicsOnCompleteWatcher(newValue: UtilityNetworkTraceWidget["showGraphicsOnComplete"]): void;
+  showSelectionAttributesWatcher(newValue: UtilityNetworkTraceWidget["showSelectionAttributes"]): void;
+  positionWatcher(newValue: string): void;
+  referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+  viewWatcher(newValue: ArcGISMapView): void;
+  checkCanTrace(): Promise<void>;
+  confirmReset(): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _createParams;
+  private _proxyEvents;
+}

package/dist/types/components/arcgis-value-picker/arcgis-value-picker.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type ValuePicker from "@arcgis/core/widgets/ValuePicker";
+import { ArcgisReferenceElement } from "../../utils/component-utils";
+import { ArcGISMapView, ArcGISSceneView } from "../types";
+export type ValuePickerWidget = InstanceType<typeof ValuePicker>;
+export declare class ArcgisValuePicker {
+  el: HTMLDivElement;
+  childElem: HTMLDivElement;
+  expandElem: HTMLArcgisExpandElement;
+  referenceElement: ArcgisReferenceElement | string;
+  view: ArcGISMapView | ArcGISSceneView;
+  position: string;
+  expandable: boolean;
+  widget: ValuePickerWidget;
+  canNext: ValuePickerWidget["canNext"];
+  canPlay: ValuePickerWidget["canPlay"];
+  canPrevious: ValuePickerWidget["canPrevious"];
+  caption: ValuePickerWidget["caption"];
+  component: ValuePickerWidget["component"];
+  layout: ValuePickerWidget["layout"];
+  loop: ValuePickerWidget["loop"];
+  playRate: ValuePickerWidget["playRate"];
+  values: ValuePickerWidget["values"];
+  widgetReady: EventEmitter<boolean>;
+  valuePickerAnimate: EventEmitter<__esri.ValuePickerAnimateEvent>;
+  valuePickerNext: EventEmitter<__esri.ValuePickerNextEvent>;
+  valuePickerPause: EventEmitter<__esri.ValuePickerPauseEvent>;
+  valuePickerPlay: EventEmitter<__esri.ValuePickerPlayEvent>;
+  valuePickerPrevious: EventEmitter<__esri.ValuePickerPreviousEvent>;
+  positionWatcher(newValue: string): void;
+  captionWatcher(newValue: ValuePickerWidget["caption"]): void;
+  componentWatcher(newValue: ValuePickerWidget["component"]): void;
+  layoutWatcher(newValue: ValuePickerWidget["layout"]): void;
+  loopWatcher(newValue: ValuePickerWidget["loop"]): void;
+  playRateWatcher(newValue: ValuePickerWidget["playRate"]): void;
+  next(): Promise<void>;
+  pause(): Promise<void>;
+  play(): Promise<void>;
+  previous(): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): VNode;
+  private _addWatchers;
+  private _createParams;
+  private _proxyEvents;
+}

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

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

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

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

package/dist/types/components/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Exported @arcgis/core types for Stencil.
+ * This is to avoid the __esri namespace types
+ * and satisfy the Stencil typing requirements
+ * for builds.
+ */
+import type Basemap from "@arcgis/core/Basemap";
+import type Graphic from "@arcgis/core/Graphic";
+import type FeatureLayer from "@arcgis/core/layers/FeatureLayer";
+import type GraphicsLayer from "@arcgis/core/layers/GraphicsLayer";
+import type Layer from "@arcgis/core/layers/Layer";
+import type MapView from "@arcgis/core/views/MapView";
+import type SceneView from "@arcgis/core/views/SceneView";
+export type ArcGISBasemap = InstanceType<typeof Basemap>;
+export type ArcGISGraphic = InstanceType<typeof Graphic>;
+export type ArcGISMapView = InstanceType<typeof MapView>;
+export type ArcGISSceneView = InstanceType<typeof SceneView>;
+export type ArcGISPortalLayer = InstanceType<typeof Layer>;
+export type ArcGISFeatureLayer = InstanceType<typeof FeatureLayer>;
+export type ArcGISGraphicsLayer = InstanceType<typeof GraphicsLayer>;