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

package/dist/components/arcgis-utility-network-trace.js

@@ -0,0 +1,271 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { a1 as newWidgetsUtilityNetworkTrace, i as importCoreReactiveUtils } from './index2.js';
+import { r as referenceElementHelper, c as checkForView, a as addHandles } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const utilityNetworkTraceCss = "";
+
+const ArcgisUtilityNetworkTrace$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisUtilityNetworkTrace extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisUtilityNetworkTraceReady = createEvent(this, "arcgisUtilityNetworkTraceReady", 7);
+        this.utilityNetworkTraceAddFlag = createEvent(this, "utilityNetworkTraceAddFlag", 7);
+        this.utilityNetworkTraceAddFlagComplete = createEvent(this, "utilityNetworkTraceAddFlagComplete", 7);
+        this.utilityNetworkTraceAddFlagError = createEvent(this, "utilityNetworkTraceAddFlagError", 7);
+        this.utilityNetworkTraceAddResultArea = createEvent(this, "utilityNetworkTraceAddResultArea", 7);
+        this.utilityNetworkTraceRemoveResultArea = createEvent(this, "utilityNetworkTraceRemoveResultArea", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.enableResultArea = false;
+        this.defaultGraphicColor = {
+            color: [255, 255, 0, 0.6],
+            haloOpacity: 0.9,
+            fillOpacity: 0.2,
+            hex: "#FFFF00"
+        };
+        this.disabled = false;
+        this.flags = [];
+        this.gdbVersion = "sde.DEFAULT";
+        this.inputSettings = [];
+        this.resultAreaProperties = undefined;
+        this.selectedTraces = [];
+        this.selectOnComplete = true;
+        this.showGraphicsOnComplete = true;
+        this.showSelectionAttributes = true;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    enableResultAreaWatcher(value) {
+        if (this.widget) {
+            this.widget.enableResultArea = value;
+        }
+    }
+    defaultGraphicColorWatcher(value) {
+        if (this.widget) {
+            this.widget.defaultGraphicColor = value;
+        }
+    }
+    disabledWatcher(value, old) {
+        if (this.widget && value !== old) {
+            this.widget.disabled = value;
+        }
+    }
+    flagsWatcher(value) {
+        if (this.widget) {
+            this.widget.flags = value;
+        }
+    }
+    gdbVersionWatcher(value) {
+        if (this.widget) {
+            this.widget.gdbVersion = value;
+        }
+    }
+    inputSettingsWatcher(value) {
+        if (this.widget) {
+            this.widget.inputSettings = value;
+        }
+    }
+    resultAreaPropertiesWatcher(value) {
+        if (this.widget) {
+            this.widget.resultAreaProperties = value;
+        }
+    }
+    selectedTracesWatcher(value) {
+        if (this.widget) {
+            this.widget.selectedTraces = value;
+        }
+    }
+    selectOnCompleteWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.selectOnComplete = value;
+        }
+    }
+    showGraphicsOnCompleteWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.showGraphicsOnComplete = value;
+        }
+    }
+    showSelectionAttributesWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.showSelectionAttributes = value;
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async checkCanTrace() {
+        await this.widget?.checkCanTrace();
+    }
+    async confirmReset() {
+        this.widget?.confirmReset();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsUtilityNetworkTrace(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._proxyEvents();
+        this._addContainer();
+        this.arcgisUtilityNetworkTraceReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, watch(() => this.widget.disabled, (value) => (this.disabled = value)));
+    }
+    _createParams() {
+        const params = {};
+        if (this.defaultGraphicColor) {
+            params.defaultGraphicColor = this.defaultGraphicColor;
+        }
+        if (this.enableResultArea !== undefined) {
+            params.enableResultArea = this.enableResultArea;
+        }
+        if (this.flags) {
+            params.flags = this.flags;
+        }
+        if (this.gdbVersion) {
+            params.gdbVersion = this.gdbVersion;
+        }
+        if (this.inputSettings) {
+            params.inputSettings = this.inputSettings;
+        }
+        if (this.resultAreaProperties) {
+            params.resultAreaProperties = this.resultAreaProperties;
+        }
+        if (this.selectedTraces) {
+            params.selectedTraces = this.selectedTraces;
+        }
+        if (this.selectOnComplete !== undefined) {
+            params.selectOnComplete = this.selectOnComplete;
+        }
+        if (this.showGraphicsOnComplete !== undefined) {
+            params.showGraphicsOnComplete = this.showGraphicsOnComplete;
+        }
+        if (this.showSelectionAttributes !== undefined) {
+            params.showSelectionAttributes = this.showSelectionAttributes;
+        }
+        if (this.view) {
+            params.view = this.view;
+        }
+        return params;
+    }
+    _proxyEvents() {
+        this.widget.on("add-flag", (e) => this.utilityNetworkTraceAddFlag.emit(e));
+        this.widget.on("add-flag-complete", (e) => this.utilityNetworkTraceAddFlagComplete.emit(e));
+        this.widget.on("add-flag-error", (e) => this.utilityNetworkTraceAddFlagError.emit(e));
+        this.widget.on("add-result-area", (e) => this.utilityNetworkTraceAddResultArea.emit(e));
+        this.widget.on("remove-result-area", (e) => this.utilityNetworkTraceRemoveResultArea.emit(e));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "enableResultArea": ["enableResultAreaWatcher"],
+        "defaultGraphicColor": ["defaultGraphicColorWatcher"],
+        "disabled": ["disabledWatcher"],
+        "flags": ["flagsWatcher"],
+        "gdbVersion": ["gdbVersionWatcher"],
+        "inputSettings": ["inputSettingsWatcher"],
+        "resultAreaProperties": ["resultAreaPropertiesWatcher"],
+        "selectedTraces": ["selectedTracesWatcher"],
+        "selectOnComplete": ["selectOnCompleteWatcher"],
+        "showGraphicsOnComplete": ["showGraphicsOnCompleteWatcher"],
+        "showSelectionAttributes": ["showSelectionAttributesWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return utilityNetworkTraceCss; }
+}, [0, "arcgis-utility-network-trace", {
+        "referenceElement": [1, "reference-element"],
+        "enableResultArea": [4, "enable-result-area"],
+        "defaultGraphicColor": [16],
+        "disabled": [1540],
+        "flags": [16],
+        "gdbVersion": [1, "gdb-version"],
+        "inputSettings": [16],
+        "resultAreaProperties": [16],
+        "selectedTraces": [16],
+        "selectOnComplete": [4, "select-on-complete"],
+        "showGraphicsOnComplete": [4, "show-graphics-on-complete"],
+        "showSelectionAttributes": [4, "show-selection-attributes"],
+        "position": [1],
+        "view": [1040],
+        "widget": [1040],
+        "checkCanTrace": [64],
+        "confirmReset": [64]
+    }, undefined, {
+        "referenceElement": ["referenceElementWatcher"],
+        "enableResultArea": ["enableResultAreaWatcher"],
+        "defaultGraphicColor": ["defaultGraphicColorWatcher"],
+        "disabled": ["disabledWatcher"],
+        "flags": ["flagsWatcher"],
+        "gdbVersion": ["gdbVersionWatcher"],
+        "inputSettings": ["inputSettingsWatcher"],
+        "resultAreaProperties": ["resultAreaPropertiesWatcher"],
+        "selectedTraces": ["selectedTracesWatcher"],
+        "selectOnComplete": ["selectOnCompleteWatcher"],
+        "showGraphicsOnComplete": ["showGraphicsOnCompleteWatcher"],
+        "showSelectionAttributes": ["showSelectionAttributesWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-utility-network-trace"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-utility-network-trace":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisUtilityNetworkTrace$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisUtilityNetworkTrace = ArcgisUtilityNetworkTrace$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisUtilityNetworkTrace, defineCustomElement };

package/{components → dist/components}/arcgis-utility-network-validate-topology.d.ts

@@ -2,8 +2,8 @@ import type { Components, JSX } from "../types/components";
 
 interface ArcgisUtilityNetworkValidateTopology extends Components.ArcgisUtilityNetworkValidateTopology, HTMLElement {}
 export const ArcgisUtilityNetworkValidateTopology: {
-  prototype: ArcgisUtilityNetworkValidateTopology;
-  new (): ArcgisUtilityNetworkValidateTopology;
+    prototype: ArcgisUtilityNetworkValidateTopology;
+    new (): ArcgisUtilityNetworkValidateTopology;
 };
 /**
  * Used to define this component and all nested components recursively.

package/dist/components/arcgis-utility-network-validate-topology.js

@@ -0,0 +1,127 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { a2 as newWidgetsUtilityNetworkValidateTopology } from './index2.js';
+import { r as referenceElementHelper, c as checkForView } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const utilityNetworkValidateTopologyCss = "arcgis-utility-network-validate-topology{}";
+
+const ArcgisUtilityNetworkValidateTopology$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisUtilityNetworkValidateTopology extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisUtilityNetworkValidateTopologyReady = createEvent(this, "arcgisUtilityNetworkValidateTopologyReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.extentToValidate = "current";
+        this.utilityNetwork = undefined;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    extentToValidateWatcher(value) {
+        if (this.widget) {
+            this.widget.extentToValidate = value;
+        }
+    }
+    utilityNetworkWatcher(value) {
+        if (this.widget) {
+            this.widget.utilityNetwork = value;
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsUtilityNetworkValidateTopology(params);
+        this.widget = widget;
+        this._addContainer();
+        this.arcgisUtilityNetworkValidateTopologyReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    _createParams() {
+        const params = {};
+        if (this.extentToValidate !== undefined) {
+            params.extentToValidate = this.extentToValidate;
+        }
+        if (this.utilityNetwork !== undefined) {
+            params.utilityNetwork = this.utilityNetwork;
+        }
+        return params;
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "extentToValidate": ["extentToValidateWatcher"],
+        "utilityNetwork": ["utilityNetworkWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return utilityNetworkValidateTopologyCss; }
+}, [0, "arcgis-utility-network-validate-topology", {
+        "referenceElement": [1, "reference-element"],
+        "extentToValidate": [1, "extent-to-validate"],
+        "utilityNetwork": [16],
+        "position": [1],
+        "view": [1040],
+        "widget": [1040]
+    }, undefined, {
+        "referenceElement": ["referenceElementWatcher"],
+        "extentToValidate": ["extentToValidateWatcher"],
+        "utilityNetwork": ["utilityNetworkWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-utility-network-validate-topology"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-utility-network-validate-topology":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisUtilityNetworkValidateTopology$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisUtilityNetworkValidateTopology = ArcgisUtilityNetworkValidateTopology$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisUtilityNetworkValidateTopology, defineCustomElement };

package/{components → dist/components}/arcgis-value-picker.d.ts

@@ -2,8 +2,8 @@ import type { Components, JSX } from "../types/components";
 
 interface ArcgisValuePicker extends Components.ArcgisValuePicker, HTMLElement {}
 export const ArcgisValuePicker: {
-  prototype: ArcgisValuePicker;
-  new (): ArcgisValuePicker;
+    prototype: ArcgisValuePicker;
+    new (): ArcgisValuePicker;
 };
 /**
  * Used to define this component and all nested components recursively.

package/dist/components/arcgis-value-picker.js

@@ -0,0 +1,221 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { a3 as newWidgetsValuePicker, i as importCoreReactiveUtils } from './index2.js';
+import { c as checkForView, a as addHandles } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const valuePickerCss = "arcgis-value-picker{}";
+
+const ArcgisValuePicker$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisValuePicker extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisValuePickerReady = createEvent(this, "arcgisValuePickerReady", 7);
+        this.arcgisValuePickerValuesChange = createEvent(this, "arcgisValuePickerValuesChange", 7);
+        this.valuePickerAnimate = createEvent(this, "valuePickerAnimate", 7);
+        this.valuePickerNext = createEvent(this, "valuePickerNext", 7);
+        this.valuePickerPause = createEvent(this, "valuePickerPause", 7);
+        this.valuePickerPlay = createEvent(this, "valuePickerPlay", 7);
+        this.valuePickerPrevious = createEvent(this, "valuePickerPrevious", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.view = undefined;
+        this.position = "bottom-left";
+        this.widget = undefined;
+        this.canNext = undefined;
+        this.canPlay = undefined;
+        this.canPrevious = undefined;
+        this.caption = undefined;
+        this.component = undefined;
+        this.layout = undefined;
+        this.loop = undefined;
+        this.playRate = undefined;
+        this.visibleElements = undefined;
+        this.values = undefined;
+    }
+    positionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, newValue);
+        }
+    }
+    captionWatcher(newValue) {
+        this.widget.caption = newValue;
+    }
+    componentWatcher(newValue) {
+        if (this.widget) {
+            this.widget.component = newValue;
+        }
+    }
+    layoutWatcher(newValue) {
+        if (this.widget) {
+            this.widget.layout = newValue;
+        }
+    }
+    loopWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.loop = newValue;
+        }
+    }
+    playRateWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.playRate = newValue;
+        }
+    }
+    visibleElementsWatcher(newValue) {
+        if (this.widget) {
+            this.widget.visibleElements = newValue;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async next() {
+        this.widget?.next();
+    }
+    async pause() {
+        this.widget?.pause();
+    }
+    async play() {
+        this.widget?.play();
+    }
+    async previous() {
+        this.widget?.previous();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsValuePicker(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._proxyEvents();
+        this.arcgisValuePickerReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Interal Methods
+    //
+    //--------------------------------------------------------------------------
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, watch(() => this.widget.canNext, (value) => (this.canNext = value), {
+            initial: true
+        }));
+        addHandles(this, watch(() => this.widget.canPlay, (value) => (this.canPlay = value), {
+            initial: true
+        }));
+        addHandles(this, watch(() => this.widget.canPrevious, (value) => (this.canPrevious = value), {
+            initial: true
+        }));
+        addHandles(this, watch(() => this.widget.values, (value) => {
+            this.values = value;
+            this.arcgisValuePickerValuesChange.emit();
+        }, {
+            initial: true
+        }));
+    }
+    _createParams() {
+        const params = {
+            container: this.childElem
+        };
+        if (this.caption) {
+            params.caption = this.caption;
+        }
+        if (this.component) {
+            params.component = this.component;
+        }
+        if (this.layout) {
+            params.layout = this.layout;
+        }
+        if (this.loop !== undefined) {
+            params.loop = this.loop;
+        }
+        if (this.playRate !== undefined) {
+            params.playRate = this.playRate;
+        }
+        if (this.visibleElements) {
+            params.visibleElements = this.visibleElements;
+        }
+        return params;
+    }
+    _proxyEvents() {
+        this.widget.on("animate", (e) => this.valuePickerAnimate.emit(e));
+        this.widget.on("next", (e) => this.valuePickerNext.emit(e));
+        this.widget.on("pause", (e) => this.valuePickerPause.emit(e));
+        this.widget.on("play", (e) => this.valuePickerPlay.emit(e));
+        this.widget.on("previous", (e) => this.valuePickerPrevious.emit(e));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "position": ["positionWatcher"],
+        "caption": ["captionWatcher"],
+        "component": ["componentWatcher"],
+        "layout": ["layoutWatcher"],
+        "loop": ["loopWatcher"],
+        "playRate": ["playRateWatcher"],
+        "visibleElements": ["visibleElementsWatcher"]
+    }; }
+    static get style() { return valuePickerCss; }
+}, [0, "arcgis-value-picker", {
+        "referenceElement": [1, "reference-element"],
+        "view": [1040],
+        "position": [1],
+        "widget": [1040],
+        "canNext": [1540, "can-next"],
+        "canPlay": [1540, "can-play"],
+        "canPrevious": [1540, "can-previous"],
+        "caption": [1],
+        "component": [16],
+        "layout": [1],
+        "loop": [4],
+        "playRate": [2, "play-rate"],
+        "visibleElements": [16],
+        "values": [1040],
+        "next": [64],
+        "pause": [64],
+        "play": [64],
+        "previous": [64]
+    }, undefined, {
+        "position": ["positionWatcher"],
+        "caption": ["captionWatcher"],
+        "component": ["componentWatcher"],
+        "layout": ["layoutWatcher"],
+        "loop": ["loopWatcher"],
+        "playRate": ["playRateWatcher"],
+        "visibleElements": ["visibleElementsWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-value-picker"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-value-picker":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisValuePicker$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisValuePicker = ArcgisValuePicker$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisValuePicker, defineCustomElement };

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

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface ArcgisVersionManagementServiceItem extends Components.ArcgisVersionManagementServiceItem, HTMLElement {}
+export const ArcgisVersionManagementServiceItem: {
+    prototype: ArcgisVersionManagementServiceItem;
+    new (): ArcgisVersionManagementServiceItem;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/arcgis-version-management-service-item.js

@@ -0,0 +1,11 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { A as ArcgisVersionManagementServiceItem$1, d as defineCustomElement$1 } from './version-management-service-item.js';
+
+const ArcgisVersionManagementServiceItem = ArcgisVersionManagementServiceItem$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisVersionManagementServiceItem, defineCustomElement };

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

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface ArcgisVersionManagementVersionItem extends Components.ArcgisVersionManagementVersionItem, HTMLElement {}
+export const ArcgisVersionManagementVersionItem: {
+    prototype: ArcgisVersionManagementVersionItem;
+    new (): ArcgisVersionManagementVersionItem;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;