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

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

@@ -0,0 +1,72 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type TableList from "@arcgis/core/widgets/TableList";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView, ArcGISSceneView } from "../types";
+export type TableListWidget = InstanceType<typeof TableList>;
+export declare class ArcgisTableList implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(newValue: ArcgisReferenceElement | string): void;
+    collapsed: boolean;
+    collapsedWatcher(value: boolean): void;
+    dragEnabled: boolean;
+    dragEnabledWatcher(value: boolean): void;
+    filterPlaceholder: string;
+    filterPlaceholderWatcher(value: string): void;
+    filterText: string;
+    filterTextWatcher(value: string): void;
+    icon: TableListWidget["icon"];
+    iconWatcher(value: TableListWidget["icon"]): void;
+    minDragEnabledItems: number;
+    minDragEnabledItemsWatcher(value: number): void;
+    minFilterItems: number;
+    minFilterItemsWatcher(value: number): void;
+    selectedItems: TableListWidget["selectedItems"];
+    selectedItemsWatcher(value: TableListWidget["selectedItems"]): void;
+    selectionMode: TableListWidget["selectionMode"];
+    selectionModeWatcher(value: TableListWidget["selectionMode"]): void;
+    listItemCreatedFunction: TableListWidget["listItemCreatedFunction"];
+    listItemCreatedFunctionWatcher(newValue: TableListWidget["listItemCreatedFunction"]): void;
+    visibleElementsCloseButton: boolean;
+    visibleElementsCloseButtonWatcher(value: boolean): void;
+    visibleElementsCollapseButton: boolean;
+    visibleElementsCollapseButtonWatcher(value: boolean): void;
+    visibleElementsErrors: boolean;
+    visibleElementsErrorsWatcher(value: boolean): void;
+    visibleElementsFilter: boolean;
+    visibleElementsFilterWatcher(value: boolean): void;
+    visibleElementsFlow: boolean;
+    visibleElementsFlowWatcher(value: boolean): void;
+    visibleElementsHeading: boolean;
+    visibleElementsHeadingWatcher(value: boolean): void;
+    visibleElementsStatusIndicators: boolean;
+    visibleElementsStatusIndicatorsWatcher(value: boolean): void;
+    visibleElementsTemporaryTableIndicators: boolean;
+    visibleElementsTemporaryTableIndicatorsWatcher(value: boolean): void;
+    position: string;
+    positionWatcher(newValue: string): void;
+    /**
+     * Internal view of the component.
+     *
+     * @internal
+     */
+    view: ArcGISMapView | ArcGISSceneView;
+    viewWatcher(newValue: ArcGISMapView | ArcGISSceneView): void;
+    /**
+     * Internal widget of the component.
+     *
+     * @internal
+     */
+    widget: TableListWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisTableListReady: EventEmitter<void>;
+    tableListTriggerAction: EventEmitter<__esri.TableListTriggerActionEvent>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _addWatchers;
+    private _createParams;
+    private _proxyEvents;
+}

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

@@ -0,0 +1,66 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type TimeSlider from "@arcgis/core/widgets/TimeSlider";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView, ArcGISSceneView } from "../types";
+export type TimeSliderWidget = InstanceType<typeof TimeSlider>;
+export declare class ArcgisTimeSlider implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    actions: TimeSliderWidget["actions"];
+    actionsWatcher(value: TimeSliderWidget["actions"]): void;
+    disabled: boolean;
+    disabledWatcher(value: boolean, old: boolean): void;
+    effectiveStops: TimeSliderWidget["effectiveStops"];
+    fullTimeExtent: TimeSliderWidget["fullTimeExtent"];
+    fullTimeExtentWatcher(value: TimeSliderWidget["fullTimeExtent"]): void;
+    layout: TimeSliderWidget["layout"];
+    layoutWatcher(value: TimeSliderWidget["layout"]): void;
+    loop: boolean;
+    loopWatcher(value: boolean): void;
+    mode: TimeSliderWidget["mode"];
+    modeWatcher(value: TimeSliderWidget["mode"]): void;
+    playRate: number;
+    playRateWatcher(value: number): void;
+    stops: TimeSliderWidget["stops"];
+    stopsWatcher(value: TimeSliderWidget["stops"]): void;
+    tickConfigs: TimeSliderWidget["tickConfigs"];
+    tickConfigsWatcher(value: TimeSliderWidget["tickConfigs"]): void;
+    timeExtent: TimeSliderWidget["timeExtent"];
+    timeExtentWatcher(value: TimeSliderWidget["timeExtent"]): void;
+    timeVisible: boolean;
+    timeVisibleWatcher(value: boolean): void;
+    timeZone: TimeSliderWidget["timeZone"];
+    timeZoneWatcher(value: TimeSliderWidget["timeZone"]): 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: TimeSliderWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisTimeSliderReady: EventEmitter<void>;
+    timeSliderTriggerAction: EventEmitter<__esri.TimeSliderTriggerActionEvent>;
+    next(): Promise<void>;
+    play(): Promise<void>;
+    previous(): Promise<void>;
+    stop(): Promise<void>;
+    updateWebDocument(webmap: __esri.WebMap): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _addWatchers;
+    private _createParams;
+    private _proxyEvents;
+}

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

@@ -0,0 +1,56 @@
+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(value: ArcgisReferenceElement | string): void;
+    error: TrackWidget["viewModel"]["error"];
+    geolocationOptions: TrackWidget["geolocationOptions"];
+    geolocationOptionsWatcher(value: TrackWidget["geolocationOptions"]): void;
+    goToLocationEnabled: boolean;
+    goToLocationEnabledWatcher(value: boolean): void;
+    graphic: TrackWidget["graphic"];
+    graphicWatcher(value: TrackWidget["graphic"]): void;
+    icon: TrackWidget["icon"];
+    iconWatcher(value: TrackWidget["icon"]): void;
+    positionFilterFunction: TrackWidget["viewModel"]["positionFilterFunction"];
+    positionFilterFunctionWatcher(value: TrackWidget["viewModel"]["positionFilterFunction"]): void;
+    rotationEnabled: boolean;
+    rotationEnabledWatcher(value: boolean): void;
+    scale: TrackWidget["scale"];
+    scaleWatcher(value: TrackWidget["scale"]): void;
+    state: TrackWidget["viewModel"]["state"];
+    tracking: boolean;
+    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: TrackWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisTrackReady: EventEmitter<void>;
+    trackComplete: EventEmitter<__esri.TrackTrackEvent>;
+    trackError: EventEmitter<__esri.TrackTrackErrorEvent>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _addWatchers;
+    private _createParams;
+    private _proxyEvents;
+}

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

@@ -0,0 +1,79 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type UtilityNetworkAssociations from "@arcgis/core/widgets/UtilityNetworkAssociations";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView } from "../types";
+export type UtilityNetworkAssociationsWidget = InstanceType<typeof UtilityNetworkAssociations>;
+export declare class ArcgisUtilityNetworkAssociations implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    autoRefreshAssociations: boolean;
+    autoRefreshAssociationsWatcher(value: boolean): void;
+    connectivityAssociationsLineSymbol: UtilityNetworkAssociationsWidget["connectivityAssociationsLineSymbol"];
+    connectivityAssociationsLineSymbolWatcher(value: UtilityNetworkAssociationsWidget["connectivityAssociationsLineSymbol"]): void;
+    includeConnectivityAssociations: boolean;
+    includeConnectivityAssociationsWatcher(value: boolean): void;
+    includeStructuralAttachmentAssociations: boolean;
+    includeStructuralAttachmentAssociationsWatcher(value: boolean): void;
+    maxAllowableAssociations: number;
+    maxAllowableAssociationsWatcher(value: number): void;
+    maxAllowableAssociationsSliderMax: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMax"];
+    maxAllowableAssociationsSliderMaxWatcher(value: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMax"]): void;
+    maxAllowableAssociationsSliderMin: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMin"];
+    maxAllowableAssociationsSliderMinWatcher(value: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderMin"]): void;
+    maxAllowableAssociationsSliderStep: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderStep"];
+    maxAllowableAssociationsSliderStepWatcher(value: UtilityNetworkAssociationsWidget["maxAllowableAssociationsSliderStep"]): void;
+    showArrowsConnectivity: boolean;
+    showArrowsConnectivityWatcher(value: boolean): void;
+    showArrowsStructuralAttachment: boolean;
+    showArrowsStructuralAttachmentWatcher(value: boolean): void;
+    showAssociationsEnabled: boolean;
+    showAssociationsEnabledWatcher(value: boolean): void;
+    structuralAttachmentAssociationsLineSymbol: UtilityNetworkAssociationsWidget["structuralAttachmentAssociationsLineSymbol"];
+    structuralAttachmentAssociationsLineSymbolWatcher(value: UtilityNetworkAssociationsWidget["structuralAttachmentAssociationsLineSymbol"]): void;
+    utilityNetwork: UtilityNetworkAssociationsWidget["utilityNetwork"];
+    utilityNetworkWatcher(value: UtilityNetworkAssociationsWidget["utilityNetwork"]): void;
+    visibleElementsConnectivityAssociationsSettingsArrowsToggle: boolean;
+    visibleElementsConnectivityAssociationsSettingsArrowsToggleWatcher(value: boolean): void;
+    visibleElementsConnectivityAssociationsSettingsCapSelect: boolean;
+    visibleElementsConnectivityAssociationsSettingsCapSelectWatcher(value: boolean): void;
+    visibleElementsConnectivityAssociationsSettingsColorPicker: boolean;
+    visibleElementsConnectivityAssociationsSettingsColorPickerWatcher(value: boolean): void;
+    visibleElementsConnectivityAssociationsSettingsStylePicker: boolean;
+    visibleElementsConnectivityAssociationsSettingsStylePickerWatcher(value: boolean): void;
+    visibleElementsConnectivityAssociationsSettingsWidthInput: boolean;
+    visibleElementsConnectivityAssociationsSettingsWidthInputWatcher(value: boolean): void;
+    visibleElementsMaxAllowableAssociationsSlider: boolean;
+    visibleElementsMaxAllowableAssociationsSliderWatcher(value: boolean): void;
+    visibleElementsStructuralAttachmentAssociationsSettingsArrowsToggle: boolean;
+    visibleElementsStructuralAttachmentAssociationsSettingsArrowsToggleWatcher(value: boolean): void;
+    visibleElementsStructuralAttachmentAssociationsSettingsCapSelect: boolean;
+    visibleElementsStructuralAttachmentAssociationsSettingsCapSelectWatcher(value: boolean): void;
+    visibleElementsStructuralAttachmentAssociationsSettingsStylePicker: boolean;
+    visibleElementsStructuralAttachmentAssociationsSettingsStylePickerWatcher(value: boolean): void;
+    visibleElementsStructuralAttachmentAssociationsSettingsWidthInput: boolean;
+    visibleElementsStructuralAttachmentAssociationsSettingsWidthInputWatcher(value: boolean): 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: UtilityNetworkAssociationsWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisUtilityNetworkAssociationsReady: EventEmitter<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _createParams;
+}

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

@@ -0,0 +1,64 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type UtilityNetworkTrace from "@arcgis/core/widgets/UtilityNetworkTrace";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView } from "../types";
+export type UtilityNetworkTraceWidget = InstanceType<typeof UtilityNetworkTrace>;
+export declare class ArcgisUtilityNetworkTrace implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    enableResultArea: boolean;
+    enableResultAreaWatcher(value: boolean): void;
+    defaultGraphicColor: UtilityNetworkTraceWidget["defaultGraphicColor"];
+    defaultGraphicColorWatcher(value: UtilityNetworkTraceWidget["defaultGraphicColor"]): void;
+    disabled: boolean;
+    disabledWatcher(value: boolean, old: boolean): void;
+    flags: UtilityNetworkTraceWidget["flags"];
+    flagsWatcher(value: UtilityNetworkTraceWidget["flags"]): void;
+    gdbVersion: string;
+    gdbVersionWatcher(value: string): void;
+    inputSettings: UtilityNetworkTraceWidget["inputSettings"];
+    inputSettingsWatcher(value: UtilityNetworkTraceWidget["inputSettings"]): void;
+    resultAreaProperties: UtilityNetworkTraceWidget["resultAreaProperties"];
+    resultAreaPropertiesWatcher(value: UtilityNetworkTraceWidget["resultAreaProperties"]): void;
+    selectedTraces: UtilityNetworkTraceWidget["selectedTraces"];
+    selectedTracesWatcher(value: UtilityNetworkTraceWidget["selectedTraces"]): void;
+    selectOnComplete: boolean;
+    selectOnCompleteWatcher(value: boolean): void;
+    showGraphicsOnComplete: boolean;
+    showGraphicsOnCompleteWatcher(value: boolean): void;
+    showSelectionAttributes: boolean;
+    showSelectionAttributesWatcher(value: boolean): 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: UtilityNetworkTraceWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisUtilityNetworkTraceReady: EventEmitter<void>;
+    utilityNetworkTraceAddFlag: EventEmitter<__esri.UtilityNetworkTraceAddFlagEvent>;
+    utilityNetworkTraceAddFlagComplete: EventEmitter<__esri.UtilityNetworkTraceAddFlagCompleteEvent>;
+    utilityNetworkTraceAddFlagError: EventEmitter<__esri.UtilityNetworkTraceAddFlagErrorEvent>;
+    utilityNetworkTraceAddResultArea: EventEmitter<__esri.UtilityNetworkTraceAddResultAreaEvent>;
+    utilityNetworkTraceRemoveResultArea: EventEmitter<__esri.UtilityNetworkTraceRemoveResultAreaEvent>;
+    checkCanTrace(): Promise<void>;
+    confirmReset(): Promise<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _addWatchers;
+    private _createParams;
+    private _proxyEvents;
+}

package/dist/types/components/utility-network-validate-topology/utility-network-validate-topology.d.ts

@@ -0,0 +1,37 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type UtilityNetworkValidateTopology from "@arcgis/core/widgets/UtilityNetworkValidateTopology";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISMapView } from "../types";
+export type UtilityNetworkValidateTopologyWidget = InstanceType<typeof UtilityNetworkValidateTopology>;
+export declare class ArcgisUtilityNetworkValidateTopology implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    extentToValidate: UtilityNetworkValidateTopologyWidget["extentToValidate"];
+    extentToValidateWatcher(value: UtilityNetworkValidateTopologyWidget["extentToValidate"]): void;
+    utilityNetwork: UtilityNetworkValidateTopologyWidget["utilityNetwork"];
+    utilityNetworkWatcher(value: UtilityNetworkValidateTopologyWidget["utilityNetwork"]): 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: UtilityNetworkValidateTopologyWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisUtilityNetworkValidateTopologyReady: EventEmitter<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _createParams;
+}

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

@@ -0,0 +1,48 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type ValuePicker from "@arcgis/core/widgets/ValuePicker";
+import type { ArcgisReferenceElement } from "../../utils/component-utils";
+import type { ArcGISMapView, ArcGISSceneView } from "../types";
+export type ValuePickerWidget = InstanceType<typeof ValuePicker>;
+export declare class ArcgisValuePicker {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    view: ArcGISMapView | ArcGISSceneView;
+    position: string;
+    positionWatcher(newValue: string): void;
+    widget: ValuePickerWidget;
+    canNext: ValuePickerWidget["canNext"];
+    canPlay: ValuePickerWidget["canPlay"];
+    canPrevious: ValuePickerWidget["canPrevious"];
+    caption: ValuePickerWidget["caption"];
+    captionWatcher(newValue: ValuePickerWidget["caption"]): void;
+    component: ValuePickerWidget["component"];
+    componentWatcher(newValue: ValuePickerWidget["component"]): void;
+    layout: ValuePickerWidget["layout"];
+    layoutWatcher(newValue: ValuePickerWidget["layout"]): void;
+    loop: ValuePickerWidget["loop"];
+    loopWatcher(newValue: ValuePickerWidget["loop"]): void;
+    playRate: ValuePickerWidget["playRate"];
+    playRateWatcher(newValue: ValuePickerWidget["playRate"]): void;
+    visibleElements: ValuePickerWidget["visibleElements"];
+    visibleElementsWatcher(newValue: ValuePickerWidget["visibleElements"]): void;
+    values: ValuePickerWidget["values"];
+    _watchHandles: __esri.WatchHandle[];
+    arcgisValuePickerReady: EventEmitter<void>;
+    arcgisValuePickerValuesChange: EventEmitter<void>;
+    valuePickerAnimate: EventEmitter<__esri.ValuePickerAnimateEvent>;
+    valuePickerNext: EventEmitter<__esri.ValuePickerNextEvent>;
+    valuePickerPause: EventEmitter<__esri.ValuePickerPauseEvent>;
+    valuePickerPlay: EventEmitter<__esri.ValuePickerPlayEvent>;
+    valuePickerPrevious: EventEmitter<__esri.ValuePickerPreviousEvent>;
+    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/version-management/t9n-types.d.ts

@@ -0,0 +1,43 @@
+export type VersionManagementStrings = {
+    label: string;
+    actions: Actions;
+    accessLevels: AccessLevels;
+    executionErrors: ExecutionErrors;
+    headers: Headers;
+    input: Input;
+    loadErrors: LoadErrors;
+};
+export type AccessLevels = {
+    private: string;
+    protected: string;
+    public: string;
+};
+export type Actions = {
+    cancelSave: string;
+    newVersion: string;
+    editVersion: string;
+    refreshVersions: string;
+    searchVersions: string;
+    saveVersion: string;
+    switchToVersion: string;
+};
+export type ExecutionErrors = {
+    invalidVersionName: string;
+    noAdvancedEditingUserTypeExtension: string;
+    noFeatureServiceFound: string;
+    notValidEnterpriseVersion: string;
+    noVersionManagementServiceFound: string;
+};
+export type Headers = {
+    manageVersions: string;
+};
+export type Input = {
+    versionAccess: string;
+    versionDescription: string;
+    versionName: string;
+    versionOwner: string;
+};
+export type LoadErrors = {
+    noFeatureServices: string;
+    noLayersProperty: string;
+};

package/dist/types/components/version-management/version-management.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentInterface, VNode } from "../../stencil-public-runtime";
+import type { VersionManagementStrings } from "./t9n-types";
+import type WebMap from "@arcgis/core/WebMap";
+import type { ArcGISMapView } from "../types";
+import type VersionManagementViewModel from "@arcgis/core/widgets/VersionManagement/VersionManagementViewModel";
+export type VersionManagementViewModelWidget = InstanceType<typeof VersionManagementViewModel>;
+export type ArcGISWebMap = InstanceType<typeof WebMap>;
+export declare class ArcgisVersionManagement implements ComponentInterface {
+    _hostElement: HTMLArcgisVersionManagementElement;
+    label: string;
+    position: string;
+    view: ArcGISMapView;
+    _lang: string;
+    _t9nLocale: string;
+    _t9nStrings: VersionManagementStrings | undefined;
+    state: string;
+    positionWatcher(newValue: string): void;
+    _watchHandles: __esri.WatchHandle[];
+    flowElement: HTMLCalciteFlowElement;
+    viewModel: __esri.VersionManagementViewModel;
+    componentDidLoad(): Promise<void>;
+    componentWillLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _checkForView;
+    private _createVersionPropertiesFlow;
+    private _getLoadError;
+    private _handleVersionItemActionClick;
+    private _handleVersionListActionClick;
+    private _switchToVersion;
+}

package/dist/types/components/version-management-service-item/version-management-service-item.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentInterface, EventEmitter, VNode } from "../../stencil-public-runtime";
+import { Event } from "../../stencil-public-runtime";
+import type { VersionManagementStrings } from "../version-management/t9n-types";
+export declare class ArcgisVersionManagementServiceItem implements ComponentInterface {
+    _hostElement: HTMLArcgisVersionManagementServiceItemElement;
+    versionItemActionClickedEventWithServiceUrl: EventEmitter<{
+        actionType: string;
+        serviceUrl: string;
+        versionInfo: __esri.VersionInfo;
+    }>;
+    versionListActionClickedEvent: EventEmitter<{
+        actionType: string;
+        serviceUrl: string;
+    }>;
+    flowElement: HTMLCalciteFlowElement;
+    heading: string;
+    serviceUrl: string;
+    strings: VersionManagementStrings;
+    viewModel: __esri.VersionManagementViewModel;
+    state: string;
+    private _versionList;
+    private _versionListEventListeners;
+    _watchHandles: __esri.WatchHandle[];
+    componentDidLoad(): Promise<void>;
+    componentWillLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addVersionListEventListeners;
+    private _removeVersionListEventListeners;
+    _versionItemActionClickedEventWithServiceUrl: (e: Event) => void;
+    _versionListActionClickedEvent: (e: Event) => void;
+}

package/dist/types/components/version-management-version-item/version-management-version-item.d.ts

@@ -0,0 +1,14 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type { VersionManagementStrings } from "../version-management/t9n-types";
+export declare class ArcgisVersionManagementVersionItem {
+    _hostElement: HTMLArcgisVersionManagementVersionItemElement;
+    versionItemActionClickedEvent: EventEmitter<{
+        actionType: string;
+        versionInfo: __esri.VersionInfo;
+    }>;
+    strings: VersionManagementStrings;
+    hasAdvEditingUte: boolean;
+    isVersioningApiAvailable: boolean;
+    versionInfo: __esri.VersionInfo;
+    render(): VNode;
+}

package/dist/types/components/version-management-version-list/version-management-version-list.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentInterface, EventEmitter, VNode } from "../../stencil-public-runtime";
+import type { VersionManagementStrings } from "../version-management/t9n-types";
+export declare class ArcgisVersionManagementVersionList implements ComponentInterface {
+    _hostElement: HTMLArcgisVersionManagementVersionListElement;
+    versionItemActionClickedEventWithServiceUrl: EventEmitter<{
+        actionType: string;
+        serviceUrl: string;
+        versionInfo: __esri.VersionInfo;
+    }>;
+    versionListActionClickedEvent: EventEmitter<{
+        actionType: string;
+        serviceUrl: string;
+    }>;
+    heading: string;
+    serviceName: string;
+    serviceUrl: string;
+    strings: VersionManagementStrings;
+    userHasAdvancedEditingUserTypeExtension: boolean;
+    versionInfos: __esri.VersionInfo[];
+    viewModel: __esri.VersionManagementViewModel;
+    state: string;
+    _watchHandles: __esri.WatchHandle[];
+    componentDidLoad(): Promise<void>;
+    componentWillLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+}

package/dist/types/components/version-management-version-properties/version-management-version-properties.d.ts

@@ -0,0 +1,22 @@
+import type { ComponentInterface, EventEmitter, VNode } from "../../stencil-public-runtime";
+import type { VersionManagementStrings } from "../version-management/t9n-types";
+export declare class ArcgisVersionManagementVersionProperties implements ComponentInterface {
+    _hostElement: HTMLArcgisVersionManagementVersionPropertiesElement;
+    flowElement: HTMLCalciteFlowElement;
+    serviceUrl: string;
+    strings: VersionManagementStrings;
+    versionInfo: __esri.VersionInfo | undefined;
+    viewModel: __esri.VersionManagementViewModel;
+    versionPropertiesSaveClickedEvent: EventEmitter<{
+        serviceUrl: string;
+        versionInfo: __esri.VersionInfo;
+    }>;
+    executionError: string;
+    state: string;
+    _watchHandles: __esri.WatchHandle[];
+    componentDidLoad(): Promise<void>;
+    componentWillLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _getExecutionError;
+}

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

@@ -0,0 +1,37 @@
+import type { EventEmitter, VNode } from "../../stencil-public-runtime";
+import type Weather from "@arcgis/core/widgets/Weather";
+import type { ArcgisReferenceElement, WidgetElement } from "../../utils/component-utils";
+import type { ArcGISSceneView } from "../types";
+export type WeatherWidget = InstanceType<typeof Weather>;
+export declare class ArcgisWeather implements WidgetElement {
+    el: HTMLDivElement;
+    childElem: HTMLDivElement;
+    referenceElement: ArcgisReferenceElement | string;
+    referenceElementWatcher(value: ArcgisReferenceElement | string): void;
+    icon: WeatherWidget["icon"];
+    iconWatcher(value: WeatherWidget["icon"]): void;
+    visibleElementsHeader: boolean;
+    visibleElementsHeaderWatcher(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: WeatherWidget;
+    _watchHandles: __esri.WatchHandle[];
+    arcgisWeatherReady: EventEmitter<void>;
+    componentDidLoad(): Promise<void>;
+    disconnectedCallback(): void;
+    render(): VNode;
+    private _addContainer;
+    private _createParams;
+}