@arcgis/core-adapter 4.34.0-next.76 → 4.34.0-next.77

package/dist/index.js

@@ -126,224 +126,224 @@ async function newAnalysisElevationProfileAnalysis(properties) {
   const ModConstructor = await importAnalysisElevationProfileAnalysis();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileLine() {
+async function importAnalysisLengthDimension() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileLine");
+    return await window.$arcgis.import("esri/analysis/LengthDimension");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileLine.js");
+  const module = await import("@arcgis/core/analysis/LengthDimension.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileLine(properties) {
-  const ModConstructor = await importAnalysisElevationProfileLine();
+async function newAnalysisLengthDimension(properties) {
+  const ModConstructor = await importAnalysisLengthDimension();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileLineChartOptions() {
+async function importAnalysisLineOfSightAnalysis() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileLineChartOptions");
+    return await window.$arcgis.import("esri/analysis/LineOfSightAnalysis");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileLineChartOptions.js");
+  const module = await import("@arcgis/core/analysis/LineOfSightAnalysis.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileLineChartOptions(properties) {
-  const ModConstructor = await importAnalysisElevationProfileLineChartOptions();
+async function newAnalysisLineOfSightAnalysis(properties) {
+  const ModConstructor = await importAnalysisLineOfSightAnalysis();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileLineGround() {
+async function importAnalysisLineOfSightAnalysisObserver() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileLineGround");
+    return await window.$arcgis.import("esri/analysis/LineOfSightAnalysisObserver");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileLineGround.js");
+  const module = await import("@arcgis/core/analysis/LineOfSightAnalysisObserver.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileLineGround(properties) {
-  const ModConstructor = await importAnalysisElevationProfileLineGround();
+async function newAnalysisLineOfSightAnalysisObserver(properties) {
+  const ModConstructor = await importAnalysisLineOfSightAnalysisObserver();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileLineInput() {
+async function importAnalysisLineOfSightAnalysisTarget() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileLineInput");
+    return await window.$arcgis.import("esri/analysis/LineOfSightAnalysisTarget");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileLineInput.js");
+  const module = await import("@arcgis/core/analysis/LineOfSightAnalysisTarget.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileLineInput(properties) {
-  const ModConstructor = await importAnalysisElevationProfileLineInput();
+async function newAnalysisLineOfSightAnalysisTarget(properties) {
+  const ModConstructor = await importAnalysisLineOfSightAnalysisTarget();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileLineQuery() {
+async function importAnalysisSliceAnalysis() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileLineQuery");
+    return await window.$arcgis.import("esri/analysis/SliceAnalysis");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileLineQuery.js");
+  const module = await import("@arcgis/core/analysis/SliceAnalysis.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileLineQuery(properties) {
-  const ModConstructor = await importAnalysisElevationProfileLineQuery();
+async function newAnalysisSliceAnalysis(properties) {
+  const ModConstructor = await importAnalysisSliceAnalysis();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileLineScene() {
+async function importAnalysisSlicePlane() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileLineScene");
+    return await window.$arcgis.import("esri/analysis/SlicePlane");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileLineScene.js");
+  const module = await import("@arcgis/core/analysis/SlicePlane.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileLineScene(properties) {
-  const ModConstructor = await importAnalysisElevationProfileLineScene();
+async function newAnalysisSlicePlane(properties) {
+  const ModConstructor = await importAnalysisSlicePlane();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileLineViewOptions() {
+async function importAnalysisViewshed() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileLineViewOptions");
+    return await window.$arcgis.import("esri/analysis/Viewshed");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileLineViewOptions.js");
+  const module = await import("@arcgis/core/analysis/Viewshed.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileLineViewOptions(properties) {
-  const ModConstructor = await importAnalysisElevationProfileLineViewOptions();
+async function newAnalysisViewshed(properties) {
+  const ModConstructor = await importAnalysisViewshed();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileUnits() {
+async function importAnalysisViewshedAnalysis() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileUnits");
+    return await window.$arcgis.import("esri/analysis/ViewshedAnalysis");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileUnits.js");
+  const module = await import("@arcgis/core/analysis/ViewshedAnalysis.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileUnits(properties) {
-  const ModConstructor = await importAnalysisElevationProfileUnits();
+async function newAnalysisViewshedAnalysis(properties) {
+  const ModConstructor = await importAnalysisViewshedAnalysis();
   return new ModConstructor(properties);
 }
-async function importAnalysisElevationProfileViewOptions() {
+async function importAnalysisVolumeMeasurementAnalysis() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ElevationProfileViewOptions");
+    return await window.$arcgis.import("esri/analysis/VolumeMeasurementAnalysis");
   }
-  const module = await import("@arcgis/core/analysis/ElevationProfileViewOptions.js");
+  const module = await import("@arcgis/core/analysis/VolumeMeasurementAnalysis.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisElevationProfileViewOptions(properties) {
-  const ModConstructor = await importAnalysisElevationProfileViewOptions();
+async function newAnalysisVolumeMeasurementAnalysis(properties) {
+  const ModConstructor = await importAnalysisVolumeMeasurementAnalysis();
   return new ModConstructor(properties);
 }
-async function importAnalysisLengthDimension() {
+async function importAnalysisElevationProfileGroundLine() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/LengthDimension");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/GroundLine");
   }
-  const module = await import("@arcgis/core/analysis/LengthDimension.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/GroundLine.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisLengthDimension(properties) {
-  const ModConstructor = await importAnalysisLengthDimension();
+async function newAnalysisElevationProfileGroundLine(properties) {
+  const ModConstructor = await importAnalysisElevationProfileGroundLine();
   return new ModConstructor(properties);
 }
-async function importAnalysisLineOfSightAnalysis() {
+async function importAnalysisElevationProfileInputLine() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/LineOfSightAnalysis");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/InputLine");
   }
-  const module = await import("@arcgis/core/analysis/LineOfSightAnalysis.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/InputLine.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisLineOfSightAnalysis(properties) {
-  const ModConstructor = await importAnalysisLineOfSightAnalysis();
+async function newAnalysisElevationProfileInputLine(properties) {
+  const ModConstructor = await importAnalysisElevationProfileInputLine();
   return new ModConstructor(properties);
 }
-async function importAnalysisLineOfSightAnalysisObserver() {
+async function importAnalysisElevationProfileLine() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/LineOfSightAnalysisObserver");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/Line");
   }
-  const module = await import("@arcgis/core/analysis/LineOfSightAnalysisObserver.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/Line.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisLineOfSightAnalysisObserver(properties) {
-  const ModConstructor = await importAnalysisLineOfSightAnalysisObserver();
+async function newAnalysisElevationProfileLine(properties) {
+  const ModConstructor = await importAnalysisElevationProfileLine();
   return new ModConstructor(properties);
 }
-async function importAnalysisLineOfSightAnalysisTarget() {
+async function importAnalysisElevationProfileLineChartOptions() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/LineOfSightAnalysisTarget");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/LineChartOptions");
   }
-  const module = await import("@arcgis/core/analysis/LineOfSightAnalysisTarget.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/LineChartOptions.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisLineOfSightAnalysisTarget(properties) {
-  const ModConstructor = await importAnalysisLineOfSightAnalysisTarget();
+async function newAnalysisElevationProfileLineChartOptions(properties) {
+  const ModConstructor = await importAnalysisElevationProfileLineChartOptions();
   return new ModConstructor(properties);
 }
-async function importAnalysisSliceAnalysis() {
+async function importAnalysisElevationProfileLineViewOptions() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/SliceAnalysis");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/LineViewOptions");
   }
-  const module = await import("@arcgis/core/analysis/SliceAnalysis.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/LineViewOptions.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisSliceAnalysis(properties) {
-  const ModConstructor = await importAnalysisSliceAnalysis();
+async function newAnalysisElevationProfileLineViewOptions(properties) {
+  const ModConstructor = await importAnalysisElevationProfileLineViewOptions();
   return new ModConstructor(properties);
 }
-async function importAnalysisSlicePlane() {
+async function importAnalysisElevationProfileQueryLine() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/SlicePlane");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/QueryLine");
   }
-  const module = await import("@arcgis/core/analysis/SlicePlane.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/QueryLine.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisSlicePlane(properties) {
-  const ModConstructor = await importAnalysisSlicePlane();
+async function newAnalysisElevationProfileQueryLine(properties) {
+  const ModConstructor = await importAnalysisElevationProfileQueryLine();
   return new ModConstructor(properties);
 }
-async function importAnalysisSupportAnalysisOriginWebScene() {
+async function importAnalysisElevationProfileSceneLine() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/support/AnalysisOriginWebScene");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/SceneLine");
   }
-  const module = await import("@arcgis/core/analysis/support/AnalysisOriginWebScene.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/SceneLine.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisSupportAnalysisOriginWebScene(properties) {
-  const ModConstructor = await importAnalysisSupportAnalysisOriginWebScene();
+async function newAnalysisElevationProfileSceneLine(properties) {
+  const ModConstructor = await importAnalysisElevationProfileSceneLine();
   return new ModConstructor(properties);
 }
-async function importAnalysisViewshed() {
+async function importAnalysisElevationProfileUnits() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/Viewshed");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/Units");
   }
-  const module = await import("@arcgis/core/analysis/Viewshed.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/Units.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisViewshed(properties) {
-  const ModConstructor = await importAnalysisViewshed();
+async function newAnalysisElevationProfileUnits(properties) {
+  const ModConstructor = await importAnalysisElevationProfileUnits();
   return new ModConstructor(properties);
 }
-async function importAnalysisViewshedAnalysis() {
+async function importAnalysisElevationProfileViewOptions() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/ViewshedAnalysis");
+    return await window.$arcgis.import("esri/analysis/ElevationProfile/ViewOptions");
   }
-  const module = await import("@arcgis/core/analysis/ViewshedAnalysis.js");
+  const module = await import("@arcgis/core/analysis/ElevationProfile/ViewOptions.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisViewshedAnalysis(properties) {
-  const ModConstructor = await importAnalysisViewshedAnalysis();
+async function newAnalysisElevationProfileViewOptions(properties) {
+  const ModConstructor = await importAnalysisElevationProfileViewOptions();
   return new ModConstructor(properties);
 }
-async function importAnalysisVolumeMeasurementCutFillOptions() {
+async function importAnalysisSupportAnalysisOriginWebScene() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/VolumeMeasurement/CutFillOptions");
+    return await window.$arcgis.import("esri/analysis/support/AnalysisOriginWebScene");
   }
-  const module = await import("@arcgis/core/analysis/VolumeMeasurement/CutFillOptions.js");
+  const module = await import("@arcgis/core/analysis/support/AnalysisOriginWebScene.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisVolumeMeasurementCutFillOptions(properties) {
-  const ModConstructor = await importAnalysisVolumeMeasurementCutFillOptions();
+async function newAnalysisSupportAnalysisOriginWebScene(properties) {
+  const ModConstructor = await importAnalysisSupportAnalysisOriginWebScene();
   return new ModConstructor(properties);
 }
-async function importAnalysisVolumeMeasurementAnalysis() {
+async function importAnalysisVolumeMeasurementCutFillOptions() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/analysis/VolumeMeasurementAnalysis");
+    return await window.$arcgis.import("esri/analysis/VolumeMeasurement/CutFillOptions");
   }
-  const module = await import("@arcgis/core/analysis/VolumeMeasurementAnalysis.js");
+  const module = await import("@arcgis/core/analysis/VolumeMeasurement/CutFillOptions.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newAnalysisVolumeMeasurementAnalysis(properties) {
-  const ModConstructor = await importAnalysisVolumeMeasurementAnalysis();
+async function newAnalysisVolumeMeasurementCutFillOptions(properties) {
+  const ModConstructor = await importAnalysisVolumeMeasurementCutFillOptions();
   return new ModConstructor(properties);
 }
 async function importCoreAccessor() {
@@ -6176,26 +6176,26 @@ async function newViewpoint(properties) {
   const ModConstructor = await importViewpoint();
   return new ModConstructor(properties);
 }
-async function importViews2dLayersBaseLayerView2D() {
+async function importViewsBasemapView() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/views/2d/layers/BaseLayerView2D");
+    return await window.$arcgis.import("esri/views/BasemapView");
   }
-  const module = await import("@arcgis/core/views/2d/layers/BaseLayerView2D.js");
+  const module = await import("@arcgis/core/views/BasemapView.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newViews2dLayersBaseLayerView2D(properties) {
-  const ModConstructor = await importViews2dLayersBaseLayerView2D();
+async function newViewsBasemapView(properties) {
+  const ModConstructor = await importViewsBasemapView();
   return new ModConstructor(properties);
 }
-async function importViews2dLayersBaseLayerViewGL2D() {
+async function importViewsGroundView() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/views/2d/layers/BaseLayerViewGL2D");
+    return await window.$arcgis.import("esri/views/GroundView");
   }
-  const module = await import("@arcgis/core/views/2d/layers/BaseLayerViewGL2D.js");
+  const module = await import("@arcgis/core/views/GroundView.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newViews2dLayersBaseLayerViewGL2D(properties) {
-  const ModConstructor = await importViews2dLayersBaseLayerViewGL2D();
+async function newViewsGroundView(properties) {
+  const ModConstructor = await importViewsGroundView();
   return new ModConstructor(properties);
 }
 async function importViews2dViewState() {
@@ -6209,6 +6209,28 @@ async function newViews2dViewState(properties) {
   const ModConstructor = await importViews2dViewState();
   return new ModConstructor(properties);
 }
+async function importViews2dLayersBaseLayerView2D() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/views/2d/layers/BaseLayerView2D");
+  }
+  const module = await import("@arcgis/core/views/2d/layers/BaseLayerView2D.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+async function newViews2dLayersBaseLayerView2D(properties) {
+  const ModConstructor = await importViews2dLayersBaseLayerView2D();
+  return new ModConstructor(properties);
+}
+async function importViews2dLayersBaseLayerViewGL2D() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/views/2d/layers/BaseLayerViewGL2D");
+  }
+  const module = await import("@arcgis/core/views/2d/layers/BaseLayerViewGL2D.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+async function newViews2dLayersBaseLayerViewGL2D(properties) {
+  const ModConstructor = await importViews2dLayersBaseLayerViewGL2D();
+  return new ModConstructor(properties);
+}
 async function importViews3dAnalysisAreaMeasurementAnalysisView3D() {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/3d/analysis/AreaMeasurementAnalysisView3D");
@@ -6398,26 +6420,15 @@ async function newViews3dWebglRenderNode(properties) {
 }
 async function importViewsAnalysisElevationProfileResult() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/views/analysis/ElevationProfileResult");
+    return await window.$arcgis.import("esri/views/analysis/ElevationProfile/Result");
   }
-  const module = await import("@arcgis/core/views/analysis/ElevationProfileResult.js");
+  const module = await import("@arcgis/core/views/analysis/ElevationProfile/Result.js");
   return isDefaultModule(module) ? module.default : module;
 }
 async function newViewsAnalysisElevationProfileResult(properties) {
   const ModConstructor = await importViewsAnalysisElevationProfileResult();
   return new ModConstructor(properties);
 }
-async function importViewsBasemapView() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/views/BasemapView");
-  }
-  const module = await import("@arcgis/core/views/BasemapView.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-async function newViewsBasemapView(properties) {
-  const ModConstructor = await importViewsBasemapView();
-  return new ModConstructor(properties);
-}
 async function importViewsDrawDraw() {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/draw/Draw");
@@ -6495,15 +6506,15 @@ async function newViewsDrawSegmentDrawAction(properties) {
   const ModConstructor = await importViewsDrawSegmentDrawAction();
   return new ModConstructor(properties);
 }
-async function importViewsGroundView() {
+async function importViewsInputInput() {
   if (isAMD) {
-    return await window.$arcgis.import("esri/views/GroundView");
+    return await window.$arcgis.import("esri/views/input/Input");
   }
-  const module = await import("@arcgis/core/views/GroundView.js");
+  const module = await import("@arcgis/core/views/input/Input.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function newViewsGroundView(properties) {
-  const ModConstructor = await importViewsGroundView();
+async function newViewsInputInput(properties) {
+  const ModConstructor = await importViewsInputInput();
   return new ModConstructor(properties);
 }
 async function importViewsInputGamepadGamepadInputDevice() {
@@ -6528,17 +6539,6 @@ async function newViewsInputGamepadGamepadSettings(properties) {
   const ModConstructor = await importViewsInputGamepadGamepadSettings();
   return new ModConstructor(properties);
 }
-async function importViewsInputInput() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/views/input/Input");
-  }
-  const module = await import("@arcgis/core/views/input/Input.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-async function newViewsInputInput(properties) {
-  const ModConstructor = await importViewsInputInput();
-  return new ModConstructor(properties);
-}
 async function importViewsInteractiveSketchSketchLabelOptions() {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/interactive/sketch/SketchLabelOptions");
@@ -11003,6 +11003,13 @@ async function importVersionManagementVersionAdaptersUtils() {
   const module = await import("@arcgis/core/versionManagement/versionAdapters/utils.js");
   return isDefaultModule(module) ? module.default : module;
 }
+async function importViews3dWebgl() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/views/3d/webgl");
+  }
+  const module = await import("@arcgis/core/views/3d/webgl.js");
+  return isDefaultModule(module) ? module.default : module;
+}
 async function importViews3dWebglManagedFBO() {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/3d/webgl/ManagedFBO");
@@ -11017,13 +11024,6 @@ async function importViews3dWebglRenderCamera() {
   const module = await import("@arcgis/core/views/3d/webgl/RenderCamera.js");
   return isDefaultModule(module) ? module.default : module;
 }
-async function importViews3dWebgl() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/views/3d/webgl");
-  }
-  const module = await import("@arcgis/core/views/3d/webgl.js");
-  return isDefaultModule(module) ? module.default : module;
-}
 async function importViews3dSupportLayerPerformanceInfo() {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/3d/support/LayerPerformanceInfo");
@@ -11248,13 +11248,13 @@ export {
   importAnalysisDimensionSimpleStyle,
   importAnalysisDirectLineMeasurementAnalysis,
   importAnalysisElevationProfileAnalysis,
+  importAnalysisElevationProfileGroundLine,
+  importAnalysisElevationProfileInputLine,
   importAnalysisElevationProfileLine,
   importAnalysisElevationProfileLineChartOptions,
-  importAnalysisElevationProfileLineGround,
-  importAnalysisElevationProfileLineInput,
-  importAnalysisElevationProfileLineQuery,
-  importAnalysisElevationProfileLineScene,
   importAnalysisElevationProfileLineViewOptions,
+  importAnalysisElevationProfileQueryLine,
+  importAnalysisElevationProfileSceneLine,
   importAnalysisElevationProfileUnits,
   importAnalysisElevationProfileViewOptions,
   importAnalysisLengthDimension,
@@ -12349,13 +12349,13 @@ export {
   newAnalysisDimensionSimpleStyle,
   newAnalysisDirectLineMeasurementAnalysis,
   newAnalysisElevationProfileAnalysis,
+  newAnalysisElevationProfileGroundLine,
+  newAnalysisElevationProfileInputLine,
   newAnalysisElevationProfileLine,
   newAnalysisElevationProfileLineChartOptions,
-  newAnalysisElevationProfileLineGround,
-  newAnalysisElevationProfileLineInput,
-  newAnalysisElevationProfileLineQuery,
-  newAnalysisElevationProfileLineScene,
   newAnalysisElevationProfileLineViewOptions,
+  newAnalysisElevationProfileQueryLine,
+  newAnalysisElevationProfileSceneLine,
   newAnalysisElevationProfileUnits,
   newAnalysisElevationProfileViewOptions,
   newAnalysisLengthDimension,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/core-adapter",
-  "version": "4.34.0-next.76",
+  "version": "4.34.0-next.77",
   "description": "ArcGIS Core Adapter",
   "type": "module",
   "main": "dist/index.cjs",