@arcgis/map-components 4.29.0-beta.7 → 4.29.0-beta.72

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

@@ -0,0 +1,125 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type WebScene from "@arcgis/core/WebScene";
+import type { ViewElement } from "../../utils/component-utils";
+import type { ArcGISSceneView } from "../types";
+export type ArcGISWebScene = InstanceType<typeof WebScene>;
+export declare class ArcgisScene implements ViewElement {
+    el: HTMLDivElement;
+    _hostElement: HTMLArcgisSceneElement;
+    allLayerViews: ArcGISSceneView["allLayerViews"];
+    alphaCompositingEnabled: ArcGISSceneView["alphaCompositingEnabled"];
+    alphaCompositingEnabledWatcher(value: ArcGISSceneView["alphaCompositingEnabled"]): void;
+    analyses: ArcGISSceneView["analyses"];
+    basemapView: ArcGISSceneView["basemapView"];
+    basemap: ArcGISWebScene["basemap"];
+    basemapWatcher(value: string): void;
+    camera: ArcGISSceneView["camera"];
+    cameraWatcher(value: ArcGISSceneView["camera"]): void;
+    center: ArcGISSceneView["center"] | string;
+    centerWatcher(value: ArcGISSceneView["center"]): void;
+    clippingArea: ArcGISSceneView["clippingArea"];
+    clippingAreaWatcher(value: ArcGISSceneView["clippingArea"]): void;
+    constraints: ArcGISSceneView["constraints"];
+    constraintsWatcher(value: ArcGISSceneView["constraints"]): void;
+    destroyDisabled: boolean;
+    environment: ArcGISSceneView["environment"];
+    environmentWatcher(value: ArcGISSceneView["environment"]): void;
+    extent: ArcGISSceneView["extent"];
+    extentWatcher(value: ArcGISSceneView["extent"]): void;
+    fatalError: ArcGISSceneView["fatalError"];
+    floors: ArcGISSceneView["floors"];
+    floorsWatcher(value: ArcGISSceneView["floors"]): void;
+    graphics: ArcGISSceneView["graphics"];
+    graphicsWatcher(value: ArcGISSceneView["graphics"]): void;
+    groundView: ArcGISSceneView["groundView"];
+    highlightOptions: ArcGISSceneView["highlightOptions"];
+    highlightOptionsWatcher(value: ArcGISSceneView["highlightOptions"]): void;
+    interacting: ArcGISSceneView["interacting"];
+    itemId: string;
+    itemIdWatcher(value: string, old: string): void;
+    layerViews: ArcGISSceneView["layerViews"];
+    magnifier: ArcGISSceneView["magnifier"];
+    map: ArcGISWebScene;
+    mapWatcher(value: ArcGISWebScene): void;
+    navigating: ArcGISSceneView["navigating"];
+    navigation: ArcGISSceneView["navigation"];
+    navigationWatcher(value: ArcGISSceneView["navigation"]): void;
+    padding: ArcGISSceneView["padding"];
+    paddingWatcher(value: ArcGISSceneView["padding"]): void;
+    performanceInfo: ArcGISSceneView["performanceInfo"];
+    popup: ArcGISSceneView["popup"];
+    popupEnabled: ArcGISSceneView["popupEnabled"];
+    popupEnabledWatcher(value: ArcGISSceneView["popupEnabled"]): void;
+    qualityProfile: ArcGISSceneView["qualityProfile"];
+    qualityProfileWatcher(value: ArcGISSceneView["qualityProfile"]): void;
+    ready: ArcGISSceneView["ready"];
+    resolution: ArcGISSceneView["resolution"];
+    scale: number;
+    scaleWatcher(value: number, old: number): void;
+    spatialReference: ArcGISSceneView["spatialReference"];
+    spatialReferenceWatcher(value: ArcGISSceneView["spatialReference"]): void;
+    stationary: ArcGISSceneView["stationary"];
+    suspended: ArcGISSceneView["suspended"];
+    theme: ArcGISSceneView["theme"];
+    themeWatcher(value: ArcGISSceneView["theme"]): void;
+    timeExtent: ArcGISSceneView["timeExtent"];
+    timeExtentWatcher(value: ArcGISSceneView["timeExtent"]): void;
+    toMap: ArcGISSceneView["toMap"];
+    toScreen: ArcGISSceneView["toScreen"];
+    updating: ArcGISSceneView["updating"];
+    viewingMode: ArcGISSceneView["viewingMode"];
+    viewingModeWatcher(value: ArcGISSceneView["viewingMode"]): void;
+    viewpoint: ArcGISSceneView["viewpoint"];
+    viewpointWatcher(value: ArcGISSceneView["viewpoint"]): void;
+    zoom: number;
+    zoomWatcher(value: number, old: number): void;
+    /**
+     * Internal view of the component.
+     */
+    view: ArcGISSceneView;
+    disableNavigation: boolean;
+    config: __esri.config;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisViewReadyChange: EventEmitter;
+    arcgisViewChange: EventEmitter;
+    arcgisViewClick: EventEmitter<__esri.ViewClickEvent>;
+    arcgisViewDoubleClick: EventEmitter<__esri.ViewDoubleClickEvent>;
+    arcgisViewDrag: EventEmitter<__esri.ViewDragEvent>;
+    arcgisViewHold: EventEmitter<__esri.ViewHoldEvent>;
+    arcgisViewImmediateClick: EventEmitter<__esri.ViewImmediateClickEvent>;
+    arcgisViewImmediateDoubleClick: EventEmitter<__esri.ViewImmediateDoubleClickEvent>;
+    arcgisViewKeyDown: EventEmitter<__esri.ViewKeyDownEvent>;
+    arcgisViewKeyUp: EventEmitter<__esri.ViewKeyUpEvent>;
+    arcgisViewLayerviewCreate: EventEmitter<__esri.ViewLayerviewCreateEvent>;
+    arcgisViewLayerviewCreateError: EventEmitter<__esri.ViewLayerviewCreateErrorEvent>;
+    arcgisViewLayerviewDestroy: EventEmitter<__esri.ViewLayerviewDestroyEvent>;
+    arcgisViewMouseWheel: EventEmitter<__esri.ViewMouseWheelEvent>;
+    arcgisViewPointerDown: EventEmitter<__esri.ViewPointerDownEvent>;
+    arcgisViewPointerEnter: EventEmitter<__esri.ViewPointerEnterEvent>;
+    arcgisViewPointerLeave: EventEmitter<__esri.ViewPointerLeaveEvent>;
+    arcgisViewPointerMove: EventEmitter<__esri.ViewPointerMoveEvent>;
+    arcgisViewPointerUp: EventEmitter<__esri.ViewPointerUpEvent>;
+    closePopup(): Promise<void>;
+    destroy(): Promise<void>;
+    goTo(target: __esri.GoToTarget3D, options?: __esri.GoToOptions3D): Promise<void>;
+    hitTest(screenPoint: __esri.ScreenPoint, options?: Record<string, any>): Promise<__esri.HitTestResult>;
+    openPopup(options?: Record<string, any>): Promise<void>;
+    takeScreenshot(options?: Record<string, any>): Promise<__esri.Screenshot>;
+    tryFatalErrorRecovery(): Promise<void>;
+    whenAnalysisView(analysis: __esri.AreaMeasurementAnalysis | __esri.DimensionAnalysis | __esri.DirectLineMeasurementAnalysis | __esri.LineOfSightAnalysis | __esri.SliceAnalysis): Promise<__esri.AreaMeasurementAnalysisView3D | __esri.DimensionAnalysisView | __esri.DirectLineMeasurementAnalysisView3D | __esri.LineOfSightAnalysisView3D | __esri.SliceAnalysisView3D>;
+    whenLayerView(layer: __esri.Layer): Promise<__esri.LayerView>;
+    connectedCallback(): Promise<void>;
+    componentWillLoad(): Promise<void>;
+    componentDidRender(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _clearWatchHandles;
+    private _addWatchers;
+    private _createMap;
+    private _createPortalItem;
+    private _createViewParams;
+    private _loadMap;
+    private _proxyEvents;
+    private _updateMap;
+}

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

@@ -0,0 +1,83 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Search from "@arcgis/core/widgets/Search";
+import type { ArcgisReferenceElement } from "../../utils/component-utils";
+import type { ExpandableComponent } from "../../utils/expandable";
+import type { 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;
+    referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+    activeMenu: SearchWidget["activeMenu"];
+    activeMenuWatcher(newValue: SearchWidget["activeMenu"]): void;
+    activeSource: SearchWidget["activeSource"];
+    activeSourceIndex: SearchWidget["activeSourceIndex"];
+    activeSourceIndexWatcher(newValue: SearchWidget["activeSourceIndex"]): void;
+    allPlaceholder: SearchWidget["allPlaceholder"];
+    allPlaceholderWatcher(newValue: SearchWidget["allPlaceholder"]): void;
+    allSources: SearchWidget["allSources"];
+    autoSelect: SearchWidget["autoSelect"];
+    autoSelectWatcher(newValue: SearchWidget["autoSelect"]): void;
+    defaultSources: SearchWidget["defaultSources"];
+    includeDefaultSources: SearchWidget["includeDefaultSources"];
+    includeDefaultSourcesWatcher(newValue: SearchWidget["includeDefaultSources"]): void;
+    locationEnabled: SearchWidget["locationEnabled"];
+    locationEnabledWatcher(newValue: SearchWidget["locationEnabled"]): void;
+    maxResults: SearchWidget["maxResults"];
+    maxResultsWatcher(newValue: SearchWidget["maxResults"]): void;
+    maxSuggestions: SearchWidget["maxSuggestions"];
+    maxSuggestionsWatcher(newValue: SearchWidget["maxSuggestions"]): void;
+    minSuggestCharacters: SearchWidget["minSuggestCharacters"];
+    minSuggestCharactersWatcher(newValue: SearchWidget["minSuggestCharacters"]): void;
+    popupEnabled: SearchWidget["popupEnabled"];
+    popupEnabledWatcher(newValue: SearchWidget["popupEnabled"]): void;
+    popupTemplate: SearchWidget["popupTemplate"];
+    popupTemplateWatcher(newValue: SearchWidget["popupTemplate"]): void;
+    portal: SearchWidget["portal"];
+    portalWatcher(newValue: SearchWidget["portal"]): void;
+    resultGraphic: SearchWidget["resultGraphic"];
+    resultGraphicEnabled: SearchWidget["resultGraphicEnabled"];
+    resultGraphicEnabledWatcher(newValue: SearchWidget["resultGraphicEnabled"]): void;
+    results: SearchWidget["results"];
+    searchAllEnabled: SearchWidget["searchAllEnabled"];
+    searchAllEnabledWatcher(newValue: SearchWidget["searchAllEnabled"]): void;
+    searchTerm: SearchWidget["searchTerm"];
+    searchTermWatcher(newValue: SearchWidget["searchTerm"]): void;
+    selectedResult: SearchWidget["selectedResult"];
+    sources: SearchWidget["sources"];
+    sourcesWatcher(newValue: SearchWidget["sources"]): void;
+    suggestions: SearchWidget["suggestions"];
+    suggestionsEnabled: SearchWidget["suggestionsEnabled"];
+    suggestionsEnabledWatcher(newValue: SearchWidget["suggestionsEnabled"]): void;
+    position: string;
+    positionWatcher(newValue: string): void;
+    expandable: boolean;
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+    widget: SearchWidget;
+    _watchHandles: __esri.WatchHandle[];
+    widgetReady: EventEmitter<{
+        widget: __esri.Search;
+    }>;
+    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>;
+    blurSearch(): Promise<void>;
+    clearSearch(): Promise<void>;
+    focusSearch(): Promise<void>;
+    search(term: __esri.Geometry | __esri.SuggestResult | number[][] | string): 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/shadow-cast/shadow-cast.d.ts

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

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

@@ -0,0 +1,56 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Sketch from "@arcgis/core/widgets/Sketch";
+import type { ArcgisReferenceElement } from "../../utils/component-utils";
+import type { ExpandableComponent } from "../../utils/expandable";
+import type { 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;
+    referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+    activeTool: SketchWidget["activeTool"];
+    availableCreateTools: SketchWidget["availableCreateTools"];
+    availableCreateToolsWatcher(newValue: SketchWidget["availableCreateTools"]): void;
+    createGraphic: SketchWidget["createGraphic"];
+    creationMode: SketchWidget["creationMode"];
+    creationModeWatcher(newValue: SketchWidget["creationMode"]): void;
+    defaultCreateOptions: SketchWidget["defaultCreateOptions"];
+    defaultCreateOptionsWatcher(newValue: SketchWidget["defaultCreateOptions"]): void;
+    defaultUpdateOptions: SketchWidget["defaultUpdateOptions"];
+    defaultUpdateOptionsWatcher(newValue: SketchWidget["defaultUpdateOptions"]): void;
+    labelOptions: SketchWidget["labelOptions"];
+    labelOptionsWatcher(newValue: SketchWidget["labelOptions"]): void;
+    layer: SketchWidget["layer"];
+    layerWatcher(newValue: SketchWidget["layer"]): void;
+    layout: SketchWidget["layout"];
+    layoutWatcher(newValue: SketchWidget["layout"]): void;
+    snappingOptions: SketchWidget["snappingOptions"];
+    snappingOptionsWatcher(newValue: SketchWidget["snappingOptions"]): void;
+    tooltipOptions: SketchWidget["tooltipOptions"];
+    tooltipOptionsWatcher(newValue: SketchWidget["tooltipOptions"]): void;
+    updateGraphics: SketchWidget["updateGraphics"];
+    visibleElements: SketchWidget["visibleElements"];
+    visibleElementsWatcher(newValue: SketchWidget["visibleElements"]): void;
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(newValue: ArcGISMapView): void;
+    position: string;
+    positionWatcher(newValue: string): void;
+    expandable: boolean;
+    widget: SketchWidget;
+    _watchHandles: __esri.WatchHandle[];
+    sketchCreate: EventEmitter<__esri.SketchCreateEvent>;
+    sketchDelete: EventEmitter<__esri.SketchDeleteEvent>;
+    sketchRedo: EventEmitter<__esri.SketchRedoEvent>;
+    sketchUndo: EventEmitter<__esri.SketchUndoEvent>;
+    sketchUpdate: EventEmitter<__esri.SketchUpdateEvent>;
+    widgetReady: EventEmitter<{
+        widget: __esri.Sketch;
+    }>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addWatchers;
+    private _createParams;
+}

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

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

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

@@ -0,0 +1,72 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Slider from "@arcgis/core/widgets/Slider";
+import type { ArcgisReferenceElement } from "../../utils/component-utils";
+import type { 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"];
+    draggableSegmentsEnabledWatcher(newValue: SliderWidget["draggableSegmentsEnabled"]): void;
+    effectiveMax: SliderWidget["effectiveMax"];
+    effectiveMaxWatcher(newValue: SliderWidget["effectiveMax"]): void;
+    effectiveMin: SliderWidget["effectiveMin"];
+    effectiveMinWatcher(newValue: SliderWidget["effectiveMin"]): void;
+    effectiveSegmentElements: SliderWidget["effectiveSegmentElements"];
+    labelElements: SliderWidget["labelElements"];
+    labelInputsEnabled: SliderWidget["labelInputsEnabled"];
+    labels: SliderWidget["labels"];
+    layout: SliderWidget["layout"];
+    layoutWatcher(newValue: SliderWidget["layout"]): void;
+    min: SliderWidget["min"];
+    minWatcher(newValue: SliderWidget["min"]): void;
+    max: SliderWidget["max"];
+    maxWatcher(newValue: SliderWidget["max"]): void;
+    maxLabelElement: SliderWidget["maxLabelElement"];
+    minLabelElement: SliderWidget["minLabelElement"];
+    precision: SliderWidget["precision"];
+    precisionWatcher(newValue: SliderWidget["precision"]): void;
+    rangeLabelInputsEnabled: SliderWidget["rangeLabelInputsEnabled"];
+    rangeLabelInputsEnabledWatcher(newValue: SliderWidget["rangeLabelInputsEnabled"]): void;
+    segmentElements: SliderWidget["segmentElements"];
+    snapOnClickEnabled: SliderWidget["snapOnClickEnabled"];
+    snapOnClickEnabledWatcher(newValue: SliderWidget["snapOnClickEnabled"]): void;
+    syncedSegmentsEnabled: SliderWidget["syncedSegmentsEnabled"];
+    syncedSegmentsEnabledWatcher(newValue: SliderWidget["syncedSegmentsEnabled"]): void;
+    thumbElements: SliderWidget["thumbElements"];
+    thumbsConstrained: SliderWidget["thumbsConstrained"];
+    thumbsConstrainedWatcher(newValue: SliderWidget["thumbsConstrained"]): void;
+    tickConfigs: SliderWidget["tickConfigs"];
+    tickConfigsWatcher(newValue: SliderWidget["tickConfigs"]): void;
+    tickElements: SliderWidget["tickElements"];
+    trackElement: SliderWidget["trackElement"];
+    steps: SliderWidget["steps"] | string;
+    stepsWatcher(newValue: SliderWidget["steps"]): void;
+    values: SliderWidget["values"] | string;
+    valuesWatcher(newValue: SliderWidget["values"] | string): void;
+    position: string;
+    expandable: boolean;
+    widget: SliderWidget;
+    _watchHandles: __esri.WatchHandle[];
+    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<{
+        widget: __esri.Slider;
+    }>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addWatchers;
+    private _createParams;
+}

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

@@ -0,0 +1,34 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Swipe from "@arcgis/core/widgets/Swipe";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { 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;
+    _watchHandles: __esri.WatchHandle[];
+    widgetReady: EventEmitter<{
+        widget: __esri.Swipe;
+    }>;
+    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/table-list/table-list.d.ts

@@ -0,0 +1,40 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type TableList from "@arcgis/core/widgets/TableList";
+import type { ArcgisReferenceElement } from "../../utils/component-utils";
+import type { ExpandableComponent } from "../../utils/expandable";
+import type { 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;
+    referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+    listItemCreatedFunction: TableListWidget["listItemCreatedFunction"];
+    listItemCreatedFunctionWatcher(newValue: TableListWidget["listItemCreatedFunction"]): void;
+    multipleSelectionEnabled: TableListWidget["multipleSelectionEnabled"];
+    multipleSelectionEnabledWatcher(newValue: TableListWidget["multipleSelectionEnabled"]): void;
+    selectionEnabled: TableListWidget["selectionEnabled"];
+    selectionEnabledWatcher(newValue: TableListWidget["selectionEnabled"]): void;
+    selectedItems: TableListWidget["selectedItems"];
+    tableItems: TableListWidget["tableItems"];
+    visibleElements: TableListWidget["visibleElements"];
+    visibleElementsWatcher(value: TableListWidget["visibleElements"]): void;
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+    position: string;
+    positionWatcher(newValue: string): void;
+    expandable: boolean;
+    widget: TableListWidget;
+    _watchHandles: __esri.WatchHandle[];
+    triggerAction: EventEmitter<__esri.TableListTriggerActionEvent>;
+    widgetReady: EventEmitter<{
+        widget: __esri.TableList;
+    }>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addWatchers;
+    private _createParams;
+    private _hookEvents;
+}

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

@@ -0,0 +1,57 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type TimeSlider from "@arcgis/core/widgets/TimeSlider";
+import type { ArcgisReferenceElement } from "../../utils/component-utils";
+import type { ExpandableComponent } from "../../utils/expandable";
+import type { 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;
+    referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+    actions: TimeSliderWidget["actions"];
+    actionsWatcher(newValue: TimeSliderWidget["actions"]): void;
+    effectiveStops: TimeSliderWidget["effectiveStops"];
+    fullTimeExtent: TimeSliderWidget["fullTimeExtent"];
+    fullTimeExtentWatcher(newValue: TimeSliderWidget["fullTimeExtent"]): void;
+    layout: TimeSliderWidget["layout"];
+    layoutWatcher(newValue: TimeSliderWidget["layout"]): void;
+    loop: TimeSliderWidget["loop"];
+    loopWatcher(newValue: TimeSliderWidget["loop"]): void;
+    mode: TimeSliderWidget["mode"];
+    modeWatcher(newValue: TimeSliderWidget["mode"]): void;
+    playRate: TimeSliderWidget["playRate"];
+    playRateWatcher(newValue: TimeSliderWidget["playRate"]): void;
+    stops: TimeSliderWidget["stops"];
+    stopsWatcher(newValue: TimeSliderWidget["stops"]): void;
+    tickConfigs: TimeSliderWidget["tickConfigs"];
+    tickConfigsWatcher(newValue: TimeSliderWidget["tickConfigs"]): void;
+    timeExtent: TimeSliderWidget["timeExtent"];
+    timeExtentWatcher(newValue: TimeSliderWidget["timeExtent"]): void;
+    timeVisible: TimeSliderWidget["timeVisible"];
+    timeVisibleWatcher(newValue: TimeSliderWidget["timeVisible"]): void;
+    timeZone: TimeSliderWidget["timeZone"];
+    timeZoneWatcher(newValue: TimeSliderWidget["timeZone"]): void;
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+    position: string;
+    positionWatcher(newValue: string): void;
+    expandable: boolean;
+    widget: TimeSliderWidget;
+    _watchHandles: __esri.WatchHandle[];
+    triggerAction: EventEmitter<__esri.TimeSliderTriggerActionEvent>;
+    widgetReady: EventEmitter<{
+        widget: __esri.TimeSlider;
+    }>;
+    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/track/track.d.ts

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

package/dist/types/components/utility-network-associations/utility-network-associations.d.ts

@@ -0,0 +1,55 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type UtilityNetworkAssociations from "@arcgis/core/widgets/UtilityNetworkAssociations";
+import type { ArcgisReferenceElement } from "../../utils/component-utils";
+import type { ExpandableComponent } from "../../utils/expandable";
+import type { ArcGISMapView } from "../types";
+export type UtilityNetworkAssociationsWidget = InstanceType<typeof UtilityNetworkAssociations>;
+export declare class ArcgisUtilityNetworkAssociations implements ExpandableComponent {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    expandElem: HTMLArcgisExpandElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+    autoRefreshAssociations: UtilityNetworkAssociationsWidget["autoRefreshAssociations"];
+    autoRefreshAssociationsWatcher(newValue: UtilityNetworkAssociationsWidget["autoRefreshAssociations"]): void;
+    connectivityAssociationsLineSymbol: UtilityNetworkAssociationsWidget["connectivityAssociationsLineSymbol"];
+    connectivityAssociationsLineSymbolWatcher(newValue: UtilityNetworkAssociationsWidget["connectivityAssociationsLineSymbol"]): void;
+    includeConnectivityAssociations: UtilityNetworkAssociationsWidget["includeConnectivityAssociations"];
+    includeConnectivityAssociationsWatcher(newValue: UtilityNetworkAssociationsWidget["includeConnectivityAssociations"]): void;
+    includeStructuralAttachmentAssociations: UtilityNetworkAssociationsWidget["includeStructuralAttachmentAssociations"];
+    includeStructuralAttachmentAssociationsWatcher(newValue: UtilityNetworkAssociationsWidget["includeStructuralAttachmentAssociations"]): void;
+    maxAllowableAssociations: UtilityNetworkAssociationsWidget["maxAllowableAssociations"];
+    maxAllowableAssociationsWatcher(newValue: UtilityNetworkAssociationsWidget["maxAllowableAssociations"]): void;
+    maxAllowableAssociationsSliderMax: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMax"];
+    maxAllowableAssociationsSliderMaxWatcher(newValue: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMax"]): void;
+    maxAllowableAssociationsSliderMin: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMin"];
+    maxAllowableAssociationsSliderMinWatcher(newValue: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMin"]): void;
+    maxAllowableAssociationsSliderStep: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderStep"];
+    maxAllowableAssociationsSliderStepWatcher(newValue: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderStep"]): void;
+    showArrowsConnectivity: UtilityNetworkAssociationsWidget["showArrowsConnectivity"];
+    showArrowsConnectivityWatcher(newValue: UtilityNetworkAssociationsWidget["showArrowsConnectivity"]): void;
+    showArrowsStructuralAttachment: UtilityNetworkAssociationsWidget["showArrowsStructuralAttachment"];
+    showArrowsStructuralAttachmentWatcher(newValue: UtilityNetworkAssociationsWidget["showArrowsStructuralAttachment"]): void;
+    showAssociationsEnabled: UtilityNetworkAssociationsWidget["showAssociationsEnabled"];
+    showAssociationsEnabledWatcher(newValue: UtilityNetworkAssociationsWidget["showAssociationsEnabled"]): void;
+    structuralAttachmentAssociationsLineSymbol: UtilityNetworkAssociationsWidget["structuralAttachmentAssociationsLineSymbol"];
+    structuralAttachmentAssociationsLineSymbolWatcher(newValue: UtilityNetworkAssociationsWidget["structuralAttachmentAssociationsLineSymbol"]): void;
+    utilityNetwork: UtilityNetworkAssociationsWidget["utilityNetwork"];
+    utilityNetworkWatcher(newValue: UtilityNetworkAssociationsWidget["utilityNetwork"]): void;
+    visibleElements: UtilityNetworkAssociationsWidget["visibleElements"];
+    visibleElementsWatcher(newValue: UtilityNetworkAssociationsWidget["visibleElements"]): void;
+    view: ArcGISMapView;
+    viewWatcher(newValue: ArcGISMapView): void;
+    position: string;
+    positionWatcher(newValue: string): void;
+    expandable: boolean;
+    widget: UtilityNetworkAssociationsWidget;
+    _watchHandles: __esri.WatchHandle[];
+    widgetReady: EventEmitter<{
+        widget: __esri.UtilityNetworkAssociations;
+    }>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _createParams;
+}