@arcgis/map-components 4.29.0-test.0 → 4.29.1

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

@@ -0,0 +1,37 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type ScaleBar from "@arcgis/core/widgets/ScaleBar";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView } from "../types";
+export type ScaleBarWidget = InstanceType<typeof ScaleBar>;
+export declare class ArcgisScaleBar implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    barStyle: ScaleBarWidget["style"];
+    styleWatcher(value: ScaleBarWidget["style"]): void;
+    unit: ScaleBarWidget["unit"];
+    unitWatcher(value: ScaleBarWidget["unit"]): void;
+    position: string;
+    positionWatcher(value: string): void;
+    /**
+     * Internal view of the component.
+     *
+     * @internal
+     */
+    view: ArcGISMapView;
+    viewWatcher(value: ArcGISMapView): void;
+    /**
+     * Internal widget of the component.
+     *
+     * @internal
+     */
+    widget: ScaleBarWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisScaleBarReady: EventEmitter<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _createParams;
+}

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

@@ -0,0 +1,56 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type ScaleRangeSlider from "@arcgis/core/widgets/ScaleRangeSlider";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView, ArcGISSceneView } from "../types";
+export type ScaleRangeSliderWidget = InstanceType<typeof ScaleRangeSlider>;
+export declare class ArcgisScaleRangeSlider implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    disabled: boolean;
+    disabledWatcher(value: boolean, old: boolean): void;
+    layer: ScaleRangeSliderWidget["layer"];
+    layerWatcher(value: ScaleRangeSliderWidget["layer"]): void;
+    maxScale: ScaleRangeSliderWidget["maxScale"];
+    maxScaleWatcher(value: ScaleRangeSliderWidget["maxScale"]): void;
+    maxScaleLimit: ScaleRangeSliderWidget["maxScaleLimit"];
+    maxScaleLimitWatcher(value: ScaleRangeSliderWidget["maxScaleLimit"]): void;
+    minScale: ScaleRangeSliderWidget["minScale"];
+    minScaleWatcher(value: ScaleRangeSliderWidget["minScale"]): void;
+    minScaleLimit: ScaleRangeSliderWidget["minScaleLimit"];
+    minScaleLimitWatcher(value: ScaleRangeSliderWidget["minScaleLimit"]): void;
+    mode: ScaleRangeSliderWidget["mode"];
+    modeWatcher(value: ScaleRangeSliderWidget["mode"]): void;
+    region: ScaleRangeSliderWidget["region"];
+    regionWatcher(value: ScaleRangeSliderWidget["region"]): void;
+    visibleElementsPreview: boolean;
+    visibleElementsPreviewWatcher(value: boolean): void;
+    visibleElementsScaleMenusMinScaleMenu: boolean;
+    visibleElementsScaleMenusMinScaleMenuWatcher(value: boolean): void;
+    visibleElementsScaleMenusMaxScaleMenu: boolean;
+    visibleElementsScaleMenusMaxScaleMenuWatcher(value: boolean): void;
+    position: string;
+    positionWatcher(value: string): void;
+    /**
+     * Internal view of the component.
+     *
+     * @internal
+     */
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(value: ArcGISMapView | ArcGISSceneView): void;
+    /**
+     * Internal widget of the component.
+     *
+     * @internal
+     */
+    widget: ScaleRangeSliderWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisScaleRangeSliderReady: EventEmitter<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _addWatchers;
+    private _createParams;
+}

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

@@ -0,0 +1,131 @@
+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: boolean;
+    alphaCompositingEnabledWatcher(value: boolean): void;
+    analyses: ArcGISSceneView["analyses"];
+    basemapView: ArcGISSceneView["basemapView"];
+    basemap: __esri.Basemap | string;
+    basemapWatcher(value: __esri.Basemap | string): void;
+    camera: ArcGISSceneView["camera"];
+    cameraWatcher(value: ArcGISSceneView["camera"]): void;
+    center: ArcGISSceneView["center"] | number[] | string;
+    centerWatcher(value: ArcGISSceneView["center"] | number[] | string, old: ArcGISSceneView["center"] | number[] | string): 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;
+    gamepad: __esri.GamepadSettings;
+    graphics: ArcGISSceneView["graphics"];
+    graphicsWatcher(value: ArcGISSceneView["graphics"]): void;
+    ground: ArcGISWebScene["ground"];
+    groundWatcher(value: string): void;
+    groundView: ArcGISSceneView["groundView"];
+    highlightOptions: ArcGISSceneView["highlightOptions"];
+    highlightOptionsWatcher(value: ArcGISSceneView["highlightOptions"]): void;
+    interacting: boolean;
+    itemId: string;
+    itemIdWatcher(value: string, old: string): void;
+    layerViews: ArcGISSceneView["layerViews"];
+    magnifier: ArcGISSceneView["magnifier"];
+    map: ArcGISWebScene;
+    mapWatcher(value: ArcGISWebScene): void;
+    navigating: boolean;
+    navigation: ArcGISSceneView["navigation"];
+    navigationWatcher(value: ArcGISSceneView["navigation"]): void;
+    padding: ArcGISSceneView["padding"];
+    paddingWatcher(value: ArcGISSceneView["padding"]): void;
+    performanceInfo: ArcGISSceneView["performanceInfo"];
+    popup: ArcGISSceneView["popup"];
+    popupWatcher(value: ArcGISSceneView["popup"]): void;
+    popupEnabled: boolean;
+    popupEnabledWatcher(value: boolean, old: boolean): void;
+    qualityProfile: ArcGISSceneView["qualityProfile"];
+    qualityProfileWatcher(value: ArcGISSceneView["qualityProfile"]): void;
+    ready: boolean;
+    resolution: ArcGISSceneView["resolution"];
+    scale: number;
+    scaleWatcher(value: number, old: number): void;
+    spatialReference: ArcGISSceneView["spatialReference"];
+    spatialReferenceWatcher(value: ArcGISSceneView["spatialReference"]): void;
+    stationary: boolean;
+    suspended: boolean;
+    theme: ArcGISSceneView["theme"];
+    themeWatcher(value: ArcGISSceneView["theme"]): void;
+    timeExtent: ArcGISSceneView["timeExtent"];
+    timeExtentWatcher(value: ArcGISSceneView["timeExtent"]): void;
+    toMap: ArcGISSceneView["toMap"];
+    toScreen: ArcGISSceneView["toScreen"];
+    updating: boolean;
+    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;
+    config: __esri.config;
+    _watchHandles: __esri.WatchHandle[];
+    /**
+     * This event is for the `ready` property and will be emitted when the view is ready.
+     * This event will also emit if the `map` property is changed.
+     */
+    arcgisViewReadyChange: EventEmitter<void>;
+    arcgisViewChange: EventEmitter<void>;
+    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<any>;
+    hitTest(screenPoint: __esri.ScreenPoint, options?: Record<string, any>): Promise<__esri.HitTestResult>;
+    openPopup(options?: Record<string, any>): Promise<any>;
+    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>;
+    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,93 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Search from "@arcgis/core/widgets/Search";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView, ArcGISSceneView } from "../types";
+export type SearchWidget = InstanceType<typeof Search>;
+export declare class ArcgisSearch implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    activeMenu: SearchWidget["activeMenu"];
+    activeMenuWatcher(value: SearchWidget["activeMenu"]): void;
+    activeSource: SearchWidget["activeSource"];
+    activeSourceIndex: number;
+    activeSourceIndexWatcher(value: number): void;
+    allPlaceholder: string;
+    allPlaceholderWatcher(value: string): void;
+    allSources: SearchWidget["allSources"];
+    autoSelect: boolean;
+    autoSelectWatcher(value: boolean): void;
+    defaultSources: SearchWidget["defaultSources"];
+    disabled: boolean;
+    disabledWatcher(value: boolean, old: boolean): void;
+    icon: SearchWidget["icon"];
+    iconWatcher(value: SearchWidget["icon"]): void;
+    includeDefaultSources: boolean;
+    includeDefaultSourcesWatcher(value: boolean): void;
+    locationEnabled: boolean;
+    locationEnabledWatcher(value: boolean): void;
+    maxResults: number;
+    maxResultsWatcher(value: number): void;
+    maxSuggestions: number;
+    maxSuggestionsWatcher(value: number): void;
+    minSuggestCharacters: number;
+    minSuggestCharactersWatcher(value: number): void;
+    popupEnabled: boolean;
+    popupEnabledWatcher(value: boolean): void;
+    popupTemplate: SearchWidget["popupTemplate"];
+    popupTemplateWatcher(value: SearchWidget["popupTemplate"]): void;
+    portal: SearchWidget["portal"];
+    portalWatcher(value: SearchWidget["portal"]): void;
+    resultGraphic: SearchWidget["resultGraphic"];
+    resultGraphicEnabled: boolean;
+    resultGraphicEnabledWatcher(value: boolean): void;
+    results: SearchWidget["results"];
+    searchAllEnabled: boolean;
+    searchAllEnabledWatcher(value: boolean): void;
+    searchTerm: SearchWidget["searchTerm"];
+    searchTermWatcher(value: SearchWidget["searchTerm"]): void;
+    selectedResult: SearchWidget["selectedResult"];
+    sources: SearchWidget["sources"];
+    sourcesWatcher(value: SearchWidget["sources"]): void;
+    suggestions: SearchWidget["suggestions"];
+    suggestionsEnabled: boolean;
+    suggestionsEnabledWatcher(value: boolean): void;
+    position: string;
+    positionWatcher(value: string): void;
+    /**
+     * Internal view of the component.
+     *
+     * @internal
+     */
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(value: ArcGISMapView | ArcGISSceneView): void;
+    /**
+     * Internal widget of the component.
+     *
+     * @internal
+     */
+    widget: SearchWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisSearchReady: EventEmitter<void>;
+    searchBlur: EventEmitter<__esri.SearchSearchBlurEvent>;
+    searchClear: EventEmitter<__esri.SearchSearchClearEvent>;
+    searchComplete: EventEmitter<__esri.SearchSearchCompleteEvent>;
+    searchFocus: EventEmitter<__esri.SearchSearchFocusEvent>;
+    searchStart: EventEmitter<__esri.SearchSearchStartEvent>;
+    searchSelectResult: EventEmitter<__esri.SearchSelectResultEvent>;
+    searchSuggestComplete: EventEmitter<__esri.SearchSuggestCompleteEvent>;
+    searchSuggestStart: 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 _addContainer;
+    private _addWatchers;
+    private _createParams;
+    private _proxyEvents;
+}

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

@@ -0,0 +1,65 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type ShadowCast from "@arcgis/core/widgets/ShadowCast";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISSceneView } from "../types";
+export type ShadowCastWidget = InstanceType<typeof ShadowCast>;
+export declare class ArcgisShadowCast implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    discreteOptions: ShadowCastWidget["viewModel"]["discreteOptions"];
+    discreteOptionsWatcher(value: ShadowCastWidget["viewModel"]["discreteOptions"]): void;
+    durationOptions: ShadowCastWidget["viewModel"]["durationOptions"];
+    durationOptionsWatcher(value: ShadowCastWidget["viewModel"]["durationOptions"]): void;
+    endTimeOfDay: number;
+    endTimeOfDayWatcher(value: number): void;
+    startTimeOfDay: number;
+    startTimeOfDayWatcher(value: number): void;
+    thresholdOptions: ShadowCastWidget["viewModel"]["thresholdOptions"];
+    thresholdOptionsWatcher(value: ShadowCastWidget["viewModel"]["thresholdOptions"]): void;
+    utcOffset: number;
+    utcOffsetWatcher(value: number): void;
+    visualizationType: ShadowCastWidget["viewModel"]["visualizationType"];
+    visualizationTypeWatcher(value: ShadowCastWidget["viewModel"]["visualizationType"]): void;
+    icon: ShadowCastWidget["icon"];
+    iconWatcher(value: ShadowCastWidget["icon"]): void;
+    visibleElementsTimeRangeSlider: boolean;
+    visibleElementsTimeRangeSliderWatcher(value: boolean): void;
+    visibleElementsTimezone: boolean;
+    visibleElementsTimezoneWatcher(value: boolean): void;
+    visibleElementsDatePicker: boolean;
+    visibleElementsDatePickerWatcher(value: boolean): void;
+    visibleElementsVisualizationOptions: boolean;
+    visibleElementsVisualizationOptionsWatcher(value: boolean): void;
+    visibleElementsColorPicker: boolean;
+    visibleElementsColorPickerWatcher(value: boolean): void;
+    visibleElementsTooltip: boolean;
+    visibleElementsTooltipWatcher(value: boolean): void;
+    position: string;
+    positionWatcher(value: string): void;
+    /**
+     * Internal view of the component.
+     *
+     * @internal
+     */
+    view: ArcGISSceneView;
+    viewWatcher(value: ArcGISSceneView): void;
+    /**
+     * Internal widget of the component.
+     *
+     * @internal
+     */
+    widget: ShadowCastWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisShadowCastReady: EventEmitter<void>;
+    getDuration(point: __esri.Point): Promise<number>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _createParams;
+    private _setViewModelParams;
+}

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

@@ -0,0 +1,113 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Sketch from "@arcgis/core/widgets/Sketch";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView, ArcGISSceneView } from "../types";
+export type SketchWidget = InstanceType<typeof Sketch>;
+export declare class ArcgisSketch implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    activeTool: SketchWidget["activeTool"];
+    availableCreateTools: SketchWidget["availableCreateTools"];
+    availableCreateToolsWatcher(value: SketchWidget["availableCreateTools"]): void;
+    createGraphic: SketchWidget["createGraphic"];
+    creationMode: SketchWidget["creationMode"];
+    creationModeWatcher(value: SketchWidget["creationMode"]): void;
+    defaultCreateOptions: SketchWidget["defaultCreateOptions"];
+    defaultCreateOptionsWatcher(value: SketchWidget["defaultCreateOptions"]): void;
+    defaultUpdateOptions: SketchWidget["defaultUpdateOptions"];
+    defaultUpdateOptionsWatcher(value: SketchWidget["defaultUpdateOptions"]): void;
+    icon: SketchWidget["icon"];
+    iconWatcher(value: SketchWidget["icon"]): void;
+    labelOptions: SketchWidget["labelOptions"];
+    labelOptionsWatcher(value: SketchWidget["labelOptions"]): void;
+    layer: SketchWidget["layer"];
+    layerWatcher(value: SketchWidget["layer"]): void;
+    layout: SketchWidget["layout"];
+    layoutWatcher(value: SketchWidget["layout"]): void;
+    pointSymbol: SketchWidget["viewModel"]["pointSymbol"];
+    pointSymbolWatcher(value: SketchWidget["viewModel"]["pointSymbol"]): void;
+    polylineSymbol: SketchWidget["viewModel"]["polylineSymbol"];
+    polylineSymbolWatcher(value: SketchWidget["viewModel"]["polylineSymbol"]): void;
+    polygonSymbol: SketchWidget["viewModel"]["polygonSymbol"];
+    polygonSymbolWatcher(value: SketchWidget["viewModel"]["polygonSymbol"]): void;
+    snappingOptions: SketchWidget["snappingOptions"];
+    snappingOptionsWatcher(value: SketchWidget["snappingOptions"]): void;
+    tooltipOptions: SketchWidget["tooltipOptions"];
+    tooltipOptionsWatcher(value: SketchWidget["tooltipOptions"]): void;
+    updateGraphics: SketchWidget["updateGraphics"];
+    visibleElementsCreateToolsPoint: boolean;
+    visibleElementsCreateToolsPointWatcher(value: boolean): void;
+    visibleElementsCreateToolsPolyline: boolean;
+    visibleElementsCreateToolsPolylineWatcher(value: boolean): void;
+    visibleElementsCreateToolsPolygon: boolean;
+    visibleElementsCreateToolsPolygonWatcher(value: boolean): void;
+    visibleElementsCreateToolsRectangle: boolean;
+    visibleElementsCreateToolsRectangleWatcher(value: boolean): void;
+    visibleElementsCreateToolsCircle: boolean;
+    visibleElementsCreateToolsCircleWatcher(value: boolean): void;
+    visibleElementsDuplicateButton: boolean;
+    visibleElementsDuplicateButtonWatcher(value: boolean): void;
+    visibleElementsSelectionToolsRectangle: boolean;
+    visibleElementsSelectionToolsRectangleWatcher(value: boolean): void;
+    visibleElementsSelectionToolsLasso: boolean;
+    visibleElementsSelectionToolsLassoWatcher(value: boolean): void;
+    visibleElementsSettingsMenu: boolean;
+    visibleElementsSettingsMenuWatcher(value: boolean): void;
+    visibleElementsLabelsToggle: boolean;
+    visibleElementsLabelsToggleWatcher(value: boolean): void;
+    visibleElementsTooltipsToggle: boolean;
+    visibleElementsTooltipsToggleWatcher(value: boolean): void;
+    visibleElementsSnappingControls: boolean;
+    visibleElementsSnappingControlsWatcher(value: boolean): void;
+    visibleElementsSnappingControlsElementsHeader: boolean;
+    visibleElementsSnappingControlsElementsHeaderWatcher(value: boolean): void;
+    visibleElementsSnappingControlsElementsEnabledToggle: boolean;
+    visibleElementsSnappingControlsElementsEnabledToggleWatcher(value: boolean): void;
+    visibleElementsSnappingControlsElementsSelfEnabledToggle: boolean;
+    visibleElementsSnappingControlsElementsSelfEnabledToggleWatcher(value: boolean): void;
+    visibleElementsSnappingControlsElementsFeatureEnabledToggle: boolean;
+    visibleElementsSnappingControlsElementsFeatureEnabledToggleWatcher(value: boolean): void;
+    visibleElementsSnappingControlsElementsLayerList: boolean;
+    visibleElementsSnappingControlsElementsLayerListWatcher(value: boolean): void;
+    visibleElementsUndoRedoMenu: boolean;
+    visibleElementsUndoRedoMenuWatcher(value: boolean): void;
+    position: string;
+    positionWatcher(value: string): void;
+    /**
+     * Internal view of the component.
+     *
+     * @internal
+     */
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(value: ArcGISMapView): void;
+    /**
+     * Internal widget of the component.
+     *
+     * @internal
+     */
+    widget: SketchWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisSketchReady: EventEmitter<void>;
+    sketchCreate: EventEmitter<__esri.SketchCreateEvent>;
+    sketchDelete: EventEmitter<__esri.SketchDeleteEvent>;
+    sketchRedo: EventEmitter<__esri.SketchRedoEvent>;
+    sketchUndo: EventEmitter<__esri.SketchUndoEvent>;
+    sketchUpdate: EventEmitter<__esri.SketchUpdateEvent>;
+    cancel(): Promise<void>;
+    complete(): Promise<void>;
+    create(tool: "circle" | "point" | "polygon" | "polyline" | "rectangle", createOptions?: __esri.SketchViewModelCreateCreateOptions): Promise<void>;
+    delete(): Promise<void>;
+    duplicate(): Promise<void>;
+    redo(): Promise<void>;
+    undo(): Promise<void>;
+    update(graphic: __esri.Graphic | __esri.Graphic[], updateOptions?: __esri.SketchViewModelUpdateUpdateOptions): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _addWatchers;
+    private _createParams;
+    private _setViewModelParams;
+}

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

@@ -0,0 +1,47 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Slice from "@arcgis/core/widgets/Slice";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISSceneView } from "../types";
+export type SliceWidget = InstanceType<typeof Slice>;
+export declare class ArcgisSlice implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    analysis: SliceWidget["analysis"];
+    excludedLayers: SliceWidget["viewModel"]["excludedLayers"];
+    excludedLayersWatcher(value: SliceWidget["viewModel"]["excludedLayers"]): void;
+    excludeGroundSurface: boolean;
+    excludeGroundSurfaceWatcher(value: boolean): void;
+    icon: SliceWidget["icon"];
+    iconWatcher(value: SliceWidget["icon"]): void;
+    shape: SliceWidget["viewModel"]["shape"];
+    shapeWatcher(value: SliceWidget["viewModel"]["shape"]): void;
+    tiltEnabled: boolean;
+    tiltEnabledWatcher(value: boolean): void;
+    position: string;
+    positionWatcher(value: string): void;
+    /**
+     * Internal view of the component.
+     *
+     * @internal
+     */
+    view: ArcGISSceneView;
+    viewWatcher(value: ArcGISSceneView): void;
+    /**
+     * Internal widget of the component.
+     *
+     * @internal
+     */
+    widget: SliceWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisSliceReady: EventEmitter<void>;
+    clear(): Promise<void>;
+    start(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    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;
+}