@arcgis/core-adapter 4.32.0-next.5 → 4.32.0-next.50

package/src/index.ts

@@ -756,6 +756,19 @@ export async function newGeometrySpatialReference(properties: __esri.SpatialRefe
   return new ModConstructor(properties);
 }
 
+export async function importGeometryOperatorsSupportTransformation(): Promise<typeof __esri.Transformation> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/support/Transformation");
+  }
+  const module = await import("@arcgis/core/geometry/operators/support/Transformation.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newGeometryOperatorsSupportTransformation(): Promise<__esri.Transformation> {
+  const ModConstructor = await importGeometryOperatorsSupportTransformation();
+  return new ModConstructor();
+}
+
 export async function importGeometrySupportGeographicTransformation(): Promise<typeof __esri.GeographicTransformation> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/support/GeographicTransformation");
@@ -1315,6 +1328,19 @@ export async function newLayersLineOfSightLayer(properties: __esri.LineOfSightLa
   return new ModConstructor(properties);
 }
 
+export async function importLayersLinkChartLayer(): Promise<typeof __esri.LinkChartLayer> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/LinkChartLayer");
+  }
+  const module = await import("@arcgis/core/layers/LinkChartLayer.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newLayersLinkChartLayer(properties: __esri.LinkChartLayerProperties): Promise<__esri.LinkChartLayer> {
+  const ModConstructor = await importLayersLinkChartLayer();
+  return new ModConstructor(properties);
+}
+
 export async function importLayersMapImageLayer(): Promise<typeof __esri.MapImageLayer> {
   if (isAMD) {
     return await window.$arcgis.import("esri/layers/MapImageLayer");
@@ -1965,19 +1991,6 @@ export async function newLayersSupportPublishingInfo(properties: __esri.Publishi
   return new ModConstructor(properties);
 }
 
-export async function importLayersSupportSceneFilter(): Promise<typeof __esri.SceneFilter> {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/layers/support/SceneFilter");
-  }
-  const module = await import("@arcgis/core/layers/support/SceneFilter.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-
-export async function newLayersSupportSceneFilter(properties: __esri.SceneFilterProperties): Promise<__esri.SceneFilter> {
-  const ModConstructor = await importLayersSupportSceneFilter();
-  return new ModConstructor(properties);
-}
-
 export async function importLayersSupportRangeDomain(): Promise<typeof __esri.RangeDomain> {
   if (isAMD) {
     return await window.$arcgis.import("esri/layers/support/RangeDomain");
@@ -2082,6 +2095,19 @@ export async function newLayersSupportRouteSymbols(properties: __esri.RouteSymbo
   return new ModConstructor(properties);
 }
 
+export async function importLayersSupportSceneFilter(): Promise<typeof __esri.SceneFilter> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/support/SceneFilter");
+  }
+  const module = await import("@arcgis/core/layers/support/SceneFilter.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newLayersSupportSceneFilter(properties: __esri.SceneFilterProperties): Promise<__esri.SceneFilter> {
+  const ModConstructor = await importLayersSupportSceneFilter();
+  return new ModConstructor(properties);
+}
+
 export async function importLayersSupportSceneModification(): Promise<typeof __esri.SceneModification> {
   if (isAMD) {
     return await window.$arcgis.import("esri/layers/support/SceneModification");
@@ -2407,29 +2433,29 @@ export async function newLayersUnsupportedLayer(properties: __esri.UnsupportedLa
   return new ModConstructor(properties);
 }
 
-export async function importLayersVideoLayer(): Promise<typeof __esri.VideoLayer> {
+export async function importLayersVectorTileLayer(): Promise<typeof __esri.VectorTileLayer> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/layers/VideoLayer");
+    return await window.$arcgis.import("esri/layers/VectorTileLayer");
   }
-  const module = await import("@arcgis/core/layers/VideoLayer.js");
+  const module = await import("@arcgis/core/layers/VectorTileLayer.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function newLayersVideoLayer(properties: __esri.VideoLayerProperties): Promise<__esri.VideoLayer> {
-  const ModConstructor = await importLayersVideoLayer();
+export async function newLayersVectorTileLayer(properties: __esri.VectorTileLayerProperties): Promise<__esri.VectorTileLayer> {
+  const ModConstructor = await importLayersVectorTileLayer();
   return new ModConstructor(properties);
 }
 
-export async function importLayersVectorTileLayer(): Promise<typeof __esri.VectorTileLayer> {
+export async function importLayersVideoLayer(): Promise<typeof __esri.VideoLayer> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/layers/VectorTileLayer");
+    return await window.$arcgis.import("esri/layers/VideoLayer");
   }
-  const module = await import("@arcgis/core/layers/VectorTileLayer.js");
+  const module = await import("@arcgis/core/layers/VideoLayer.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function newLayersVectorTileLayer(properties: __esri.VectorTileLayerProperties): Promise<__esri.VectorTileLayer> {
-  const ModConstructor = await importLayersVectorTileLayer();
+export async function newLayersVideoLayer(properties: __esri.VideoLayerProperties): Promise<__esri.VideoLayer> {
+  const ModConstructor = await importLayersVideoLayer();
   return new ModConstructor(properties);
 }
 
@@ -2511,6 +2537,71 @@ export async function newLayersWMTSLayer(properties: __esri.WMTSLayerProperties)
   return new ModConstructor(properties);
 }
 
+export async function importLinkChartChronologicalLayoutSettings(): Promise<typeof __esri.ChronologicalLayoutSettings> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/linkChart/ChronologicalLayoutSettings");
+  }
+  const module = await import("@arcgis/core/linkChart/ChronologicalLayoutSettings.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newLinkChartChronologicalLayoutSettings(properties: __esri.ChronologicalLayoutSettingsProperties): Promise<__esri.ChronologicalLayoutSettings> {
+  const ModConstructor = await importLinkChartChronologicalLayoutSettings();
+  return new ModConstructor(properties);
+}
+
+export async function importLinkChartLayoutSettings(): Promise<typeof __esri.LayoutSettings> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/linkChart/LayoutSettings");
+  }
+  const module = await import("@arcgis/core/linkChart/LayoutSettings.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newLinkChartLayoutSettings(properties: __esri.LayoutSettingsProperties): Promise<__esri.LayoutSettings> {
+  const ModConstructor = await importLinkChartLayoutSettings();
+  return new ModConstructor(properties);
+}
+
+export async function importLinkChartLinkChartProperties(): Promise<typeof __esri.LinkChartProperties> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/linkChart/LinkChartProperties");
+  }
+  const module = await import("@arcgis/core/linkChart/LinkChartProperties.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newLinkChartLinkChartProperties(properties: __esri.LinkChartPropertiesProperties): Promise<__esri.LinkChartProperties> {
+  const ModConstructor = await importLinkChartLinkChartProperties();
+  return new ModConstructor(properties);
+}
+
+export async function importLinkChartNonspatialDataDisplay(): Promise<typeof __esri.NonspatialDataDisplay> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/linkChart/NonspatialDataDisplay");
+  }
+  const module = await import("@arcgis/core/linkChart/NonspatialDataDisplay.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newLinkChartNonspatialDataDisplay(properties: __esri.NonspatialDataDisplayProperties): Promise<__esri.NonspatialDataDisplay> {
+  const ModConstructor = await importLinkChartNonspatialDataDisplay();
+  return new ModConstructor(properties);
+}
+
+export async function importLinkChartOrganicLayoutSettings(): Promise<typeof __esri.OrganicLayoutSettings> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/linkChart/OrganicLayoutSettings");
+  }
+  const module = await import("@arcgis/core/linkChart/OrganicLayoutSettings.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newLinkChartOrganicLayoutSettings(properties: __esri.OrganicLayoutSettingsProperties): Promise<__esri.OrganicLayoutSettings> {
+  const ModConstructor = await importLinkChartOrganicLayoutSettings();
+  return new ModConstructor(properties);
+}
+
 export async function importMap(): Promise<typeof __esri.Map> {
   if (isAMD) {
     return await window.$arcgis.import("esri/Map");
@@ -3252,6 +3343,19 @@ export async function newRenderersRasterColormapRenderer(properties: __esri.Rast
   return new ModConstructor(properties);
 }
 
+export async function importRenderersSupportRasterPresetRenderer(): Promise<typeof __esri.RasterPresetRenderer> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/renderers/support/RasterPresetRenderer");
+  }
+  const module = await import("@arcgis/core/renderers/support/RasterPresetRenderer.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRenderersSupportRasterPresetRenderer(properties: __esri.RasterPresetRendererProperties): Promise<__esri.RasterPresetRenderer> {
+  const ModConstructor = await importRenderersSupportRasterPresetRenderer();
+  return new ModConstructor(properties);
+}
+
 export async function importRenderersRasterShadedReliefRenderer(): Promise<typeof __esri.RasterShadedReliefRenderer> {
   if (isAMD) {
     return await window.$arcgis.import("esri/renderers/RasterShadedReliefRenderer");
@@ -3746,6 +3850,19 @@ export async function newRestKnowledgeGraphGraphQueryResult(properties: __esri.G
   return new ModConstructor(properties);
 }
 
+export async function importRestKnowledgeGraphGraphQueryResultHeader(): Promise<typeof __esri.GraphQueryResultHeader> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/knowledgeGraph/GraphQueryResultHeader");
+  }
+  const module = await import("@arcgis/core/rest/knowledgeGraph/GraphQueryResultHeader.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestKnowledgeGraphGraphQueryResultHeader(properties: __esri.GraphQueryResultHeaderProperties): Promise<__esri.GraphQueryResultHeader> {
+  const ModConstructor = await importRestKnowledgeGraphGraphQueryResultHeader();
+  return new ModConstructor(properties);
+}
+
 export async function importRestKnowledgeGraphGraphQueryStreaming(): Promise<typeof __esri.GraphQueryStreaming> {
   if (isAMD) {
     return await window.$arcgis.import("esri/rest/knowledgeGraph/GraphQueryStreaming");
@@ -3902,6 +4019,19 @@ export async function newRestKnowledgeGraphServiceDefinition(properties: __esri.
   return new ModConstructor(properties);
 }
 
+export async function importRestKnowledgeGraphSourceTypeValueBehavior(): Promise<typeof __esri.SourceTypeValueBehavior> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/knowledgeGraph/SourceTypeValueBehavior");
+  }
+  const module = await import("@arcgis/core/rest/knowledgeGraph/SourceTypeValueBehavior.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestKnowledgeGraphSourceTypeValueBehavior(properties: __esri.SourceTypeValueBehaviorProperties): Promise<__esri.SourceTypeValueBehavior> {
+  const ModConstructor = await importRestKnowledgeGraphSourceTypeValueBehavior();
+  return new ModConstructor(properties);
+}
+
 export async function importRestNetworksSupportAggregatedGeometry(): Promise<typeof __esri.AggregatedGeometry> {
   if (isAMD) {
     return await window.$arcgis.import("esri/rest/networks/support/AggregatedGeometry");
@@ -4084,6 +4214,84 @@ export async function newRestSupportAddressCandidate(properties: __esri.AddressC
   return new ModConstructor(properties);
 }
 
+export async function importRestSupportAttributeBinsQuery(): Promise<typeof __esri.AttributeBinsQuery> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/AttributeBinsQuery");
+  }
+  const module = await import("@arcgis/core/rest/support/AttributeBinsQuery.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportAttributeBinsQuery(properties: __esri.AttributeBinsQueryProperties): Promise<__esri.AttributeBinsQuery> {
+  const ModConstructor = await importRestSupportAttributeBinsQuery();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportAutoIntervalBinParameters(): Promise<typeof __esri.AutoIntervalBinParameters> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/AutoIntervalBinParameters");
+  }
+  const module = await import("@arcgis/core/rest/support/AutoIntervalBinParameters.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportAutoIntervalBinParameters(properties: __esri.AutoIntervalBinParametersProperties): Promise<__esri.AutoIntervalBinParameters> {
+  const ModConstructor = await importRestSupportAutoIntervalBinParameters();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportFixedBoundariesBinParameters(): Promise<typeof __esri.FixedBoundariesBinParameters> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/FixedBoundariesBinParameters");
+  }
+  const module = await import("@arcgis/core/rest/support/FixedBoundariesBinParameters.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportFixedBoundariesBinParameters(properties: __esri.FixedBoundariesBinParametersProperties): Promise<__esri.FixedBoundariesBinParameters> {
+  const ModConstructor = await importRestSupportFixedBoundariesBinParameters();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportFixedIntervalBinParameters(): Promise<typeof __esri.FixedIntervalBinParameters> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/FixedIntervalBinParameters");
+  }
+  const module = await import("@arcgis/core/rest/support/FixedIntervalBinParameters.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportFixedIntervalBinParameters(properties: __esri.FixedIntervalBinParametersProperties): Promise<__esri.FixedIntervalBinParameters> {
+  const ModConstructor = await importRestSupportFixedIntervalBinParameters();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportDateBinParameters(): Promise<typeof __esri.DateBinParameters> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/DateBinParameters");
+  }
+  const module = await import("@arcgis/core/rest/support/DateBinParameters.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportDateBinParameters(properties: __esri.DateBinParametersProperties): Promise<__esri.DateBinParameters> {
+  const ModConstructor = await importRestSupportDateBinParameters();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportDateBinTimeInterval(): Promise<typeof __esri.DateBinTimeInterval> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/DateBinTimeInterval");
+  }
+  const module = await import("@arcgis/core/rest/support/DateBinTimeInterval.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportDateBinTimeInterval(properties: __esri.DateBinTimeIntervalProperties): Promise<__esri.DateBinTimeInterval> {
+  const ModConstructor = await importRestSupportDateBinTimeInterval();
+  return new ModConstructor(properties);
+}
+
 export async function importRestSupportAlgorithmicColorRamp(): Promise<typeof __esri.AlgorithmicColorRamp> {
   if (isAMD) {
     return await window.$arcgis.import("esri/rest/support/AlgorithmicColorRamp");
@@ -4136,6 +4344,32 @@ export async function newRestSupportAttachmentQuery(properties: __esri.Attachmen
   return new ModConstructor(properties);
 }
 
+export async function importRestSupportBaseImageMeasureParameters(): Promise<typeof __esri.BaseImageMeasureParameters> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/BaseImageMeasureParameters");
+  }
+  const module = await import("@arcgis/core/rest/support/BaseImageMeasureParameters.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportBaseImageMeasureParameters(properties: __esri.BaseImageMeasureParametersProperties): Promise<__esri.BaseImageMeasureParameters> {
+  const ModConstructor = await importRestSupportBaseImageMeasureParameters();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportBaseImageMeasureResult(): Promise<typeof __esri.BaseImageMeasureResult> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/BaseImageMeasureResult");
+  }
+  const module = await import("@arcgis/core/rest/support/BaseImageMeasureResult.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportBaseImageMeasureResult(properties: __esri.BaseImageMeasureResultProperties): Promise<__esri.BaseImageMeasureResult> {
+  const ModConstructor = await importRestSupportBaseImageMeasureResult();
+  return new ModConstructor(properties);
+}
+
 export async function importRestSupportBufferParameters(): Promise<typeof __esri.BufferParameters> {
   if (isAMD) {
     return await window.$arcgis.import("esri/rest/support/BufferParameters");
@@ -4526,58 +4760,6 @@ export async function newRestSupportImageBoundaryResult(properties: __esri.Image
   return new ModConstructor(properties);
 }
 
-export async function importRestSupportImageHistogramParameters(): Promise<typeof __esri.ImageHistogramParameters> {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImageHistogramParameters");
-  }
-  const module = await import("@arcgis/core/rest/support/ImageHistogramParameters.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-
-export async function newRestSupportImageHistogramParameters(properties: __esri.ImageHistogramParametersProperties): Promise<__esri.ImageHistogramParameters> {
-  const ModConstructor = await importRestSupportImageHistogramParameters();
-  return new ModConstructor(properties);
-}
-
-export async function importRestSupportImageIdentifyParameters(): Promise<typeof __esri.ImageIdentifyParameters> {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImageIdentifyParameters");
-  }
-  const module = await import("@arcgis/core/rest/support/ImageIdentifyParameters.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-
-export async function newRestSupportImageIdentifyParameters(properties: __esri.ImageIdentifyParametersProperties): Promise<__esri.ImageIdentifyParameters> {
-  const ModConstructor = await importRestSupportImageIdentifyParameters();
-  return new ModConstructor(properties);
-}
-
-export async function importRestSupportImageIdentifyResult(): Promise<typeof __esri.ImageIdentifyResult> {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImageIdentifyResult");
-  }
-  const module = await import("@arcgis/core/rest/support/ImageIdentifyResult.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-
-export async function newRestSupportImageIdentifyResult(properties: __esri.ImageIdentifyResultProperties): Promise<__esri.ImageIdentifyResult> {
-  const ModConstructor = await importRestSupportImageIdentifyResult();
-  return new ModConstructor(properties);
-}
-
-export async function importRestSupportImageInspectionInfo(): Promise<typeof __esri.ImageInspectionInfo> {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImageInspectionInfo");
-  }
-  const module = await import("@arcgis/core/rest/support/ImageInspectionInfo.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-
-export async function newRestSupportImageInspectionInfo(properties: __esri.ImageInspectionInfoProperties): Promise<__esri.ImageInspectionInfo> {
-  const ModConstructor = await importRestSupportImageInspectionInfo();
-  return new ModConstructor(properties);
-}
-
 export async function importRestSupportImageDistanceParameters(): Promise<typeof __esri.ImageDistanceParameters> {
   if (isAMD) {
     return await window.$arcgis.import("esri/rest/support/ImageDistanceParameters");
@@ -4669,22 +4851,74 @@ export async function newRestSupportImageHeightResult(properties: __esri.ImageHe
   return new ModConstructor(properties);
 }
 
-export async function importRestSupportImageParameters(): Promise<typeof __esri.ImageParameters> {
+export async function importRestSupportImageHistogramParameters(): Promise<typeof __esri.ImageHistogramParameters> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImageParameters");
+    return await window.$arcgis.import("esri/rest/support/ImageHistogramParameters");
   }
-  const module = await import("@arcgis/core/rest/support/ImageParameters.js");
+  const module = await import("@arcgis/core/rest/support/ImageHistogramParameters.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function newRestSupportImageParameters(properties: __esri.ImageParametersProperties): Promise<__esri.ImageParameters> {
-  const ModConstructor = await importRestSupportImageParameters();
+export async function newRestSupportImageHistogramParameters(properties: __esri.ImageHistogramParametersProperties): Promise<__esri.ImageHistogramParameters> {
+  const ModConstructor = await importRestSupportImageHistogramParameters();
   return new ModConstructor(properties);
 }
 
-export async function importRestSupportImagePixelLocationParameters(): Promise<typeof __esri.ImagePixelLocationParameters> {
+export async function importRestSupportImageIdentifyParameters(): Promise<typeof __esri.ImageIdentifyParameters> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImagePixelLocationParameters");
+    return await window.$arcgis.import("esri/rest/support/ImageIdentifyParameters");
+  }
+  const module = await import("@arcgis/core/rest/support/ImageIdentifyParameters.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportImageIdentifyParameters(properties: __esri.ImageIdentifyParametersProperties): Promise<__esri.ImageIdentifyParameters> {
+  const ModConstructor = await importRestSupportImageIdentifyParameters();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportImageIdentifyResult(): Promise<typeof __esri.ImageIdentifyResult> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/ImageIdentifyResult");
+  }
+  const module = await import("@arcgis/core/rest/support/ImageIdentifyResult.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportImageIdentifyResult(properties: __esri.ImageIdentifyResultProperties): Promise<__esri.ImageIdentifyResult> {
+  const ModConstructor = await importRestSupportImageIdentifyResult();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportImageInspectionInfo(): Promise<typeof __esri.ImageInspectionInfo> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/ImageInspectionInfo");
+  }
+  const module = await import("@arcgis/core/rest/support/ImageInspectionInfo.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportImageInspectionInfo(properties: __esri.ImageInspectionInfoProperties): Promise<__esri.ImageInspectionInfo> {
+  const ModConstructor = await importRestSupportImageInspectionInfo();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportImageParameters(): Promise<typeof __esri.ImageParameters> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/ImageParameters");
+  }
+  const module = await import("@arcgis/core/rest/support/ImageParameters.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newRestSupportImageParameters(properties: __esri.ImageParametersProperties): Promise<__esri.ImageParameters> {
+  const ModConstructor = await importRestSupportImageParameters();
+  return new ModConstructor(properties);
+}
+
+export async function importRestSupportImagePixelLocationParameters(): Promise<typeof __esri.ImagePixelLocationParameters> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/rest/support/ImagePixelLocationParameters");
   }
   const module = await import("@arcgis/core/rest/support/ImagePixelLocationParameters.js");
   return isDefaultModule(module) ? module.default : module;
@@ -4773,29 +5007,29 @@ export async function newRestSupportImageSampleResult(properties: __esri.ImageSa
   return new ModConstructor(properties);
 }
 
-export async function importRestSupportImageToMapParameters(): Promise<typeof __esri.ImageToMapParameters> {
+export async function importRestSupportImageToMapMultirayParameters(): Promise<typeof __esri.ImageToMapMultirayParameters> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImageToMapParameters");
+    return await window.$arcgis.import("esri/rest/support/ImageToMapMultirayParameters");
   }
-  const module = await import("@arcgis/core/rest/support/ImageToMapParameters.js");
+  const module = await import("@arcgis/core/rest/support/ImageToMapMultirayParameters.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function newRestSupportImageToMapParameters(properties: __esri.ImageToMapParametersProperties): Promise<__esri.ImageToMapParameters> {
-  const ModConstructor = await importRestSupportImageToMapParameters();
+export async function newRestSupportImageToMapMultirayParameters(properties: __esri.ImageToMapMultirayParametersProperties): Promise<__esri.ImageToMapMultirayParameters> {
+  const ModConstructor = await importRestSupportImageToMapMultirayParameters();
   return new ModConstructor(properties);
 }
 
-export async function importRestSupportImageToMapMultirayParameters(): Promise<typeof __esri.ImageToMapMultirayParameters> {
+export async function importRestSupportImageToMapParameters(): Promise<typeof __esri.ImageToMapParameters> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/ImageToMapMultirayParameters");
+    return await window.$arcgis.import("esri/rest/support/ImageToMapParameters");
   }
-  const module = await import("@arcgis/core/rest/support/ImageToMapMultirayParameters.js");
+  const module = await import("@arcgis/core/rest/support/ImageToMapParameters.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function newRestSupportImageToMapMultirayParameters(properties: __esri.ImageToMapMultirayParametersProperties): Promise<__esri.ImageToMapMultirayParameters> {
-  const ModConstructor = await importRestSupportImageToMapMultirayParameters();
+export async function newRestSupportImageToMapParameters(properties: __esri.ImageToMapParametersProperties): Promise<__esri.ImageToMapParameters> {
+  const ModConstructor = await importRestSupportImageToMapParameters();
   return new ModConstructor(properties);
 }
 
@@ -4903,29 +5137,29 @@ export async function newRestSupportMeasureAreaFromImageResult(properties: __esr
   return new ModConstructor(properties);
 }
 
-export async function importRestSupportMeasureLengthFromImageResult(): Promise<typeof __esri.MeasureLengthFromImageResult> {
+export async function importRestSupportMeasureFromImageParameters(): Promise<typeof __esri.MeasureFromImageParameters> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/MeasureLengthFromImageResult");
+    return await window.$arcgis.import("esri/rest/support/MeasureFromImageParameters");
   }
-  const module = await import("@arcgis/core/rest/support/MeasureLengthFromImageResult.js");
+  const module = await import("@arcgis/core/rest/support/MeasureFromImageParameters.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function newRestSupportMeasureLengthFromImageResult(properties: __esri.MeasureLengthFromImageResultProperties): Promise<__esri.MeasureLengthFromImageResult> {
-  const ModConstructor = await importRestSupportMeasureLengthFromImageResult();
+export async function newRestSupportMeasureFromImageParameters(properties: __esri.MeasureFromImageParametersProperties): Promise<__esri.MeasureFromImageParameters> {
+  const ModConstructor = await importRestSupportMeasureFromImageParameters();
   return new ModConstructor(properties);
 }
 
-export async function importRestSupportMeasureFromImageParameters(): Promise<typeof __esri.MeasureFromImageParameters> {
+export async function importRestSupportMeasureLengthFromImageResult(): Promise<typeof __esri.MeasureLengthFromImageResult> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/rest/support/MeasureFromImageParameters");
+    return await window.$arcgis.import("esri/rest/support/MeasureLengthFromImageResult");
   }
-  const module = await import("@arcgis/core/rest/support/MeasureFromImageParameters.js");
+  const module = await import("@arcgis/core/rest/support/MeasureLengthFromImageResult.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function newRestSupportMeasureFromImageParameters(properties: __esri.MeasureFromImageParametersProperties): Promise<__esri.MeasureFromImageParameters> {
-  const ModConstructor = await importRestSupportMeasureFromImageParameters();
+export async function newRestSupportMeasureLengthFromImageResult(properties: __esri.MeasureLengthFromImageResultProperties): Promise<__esri.MeasureLengthFromImageResult> {
+  const ModConstructor = await importRestSupportMeasureLengthFromImageResult();
   return new ModConstructor(properties);
 }
 
@@ -6125,6 +6359,19 @@ export async function newViews2dViewState(properties: __esri.ViewStateProperties
   return new ModConstructor(properties);
 }
 
+export async function importViews2dSupportHighlightGroup(): Promise<typeof __esri.HighlightGroup> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/views/2d/support/HighlightGroup");
+  }
+  const module = await import("@arcgis/core/views/2d/support/HighlightGroup.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newViews2dSupportHighlightGroup(properties: __esri.HighlightGroupProperties): Promise<__esri.HighlightGroup> {
+  const ModConstructor = await importViews2dSupportHighlightGroup();
+  return new ModConstructor(properties);
+}
+
 export async function importViews3dAnalysisAreaMeasurementAnalysisView3D(): Promise<typeof __esri.AreaMeasurementAnalysisView3D> {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/3d/analysis/AreaMeasurementAnalysisView3D");
@@ -6645,6 +6892,19 @@ export async function newViewsLayersFeatureLayerView(properties: __esri.FeatureL
   return new ModConstructor(properties);
 }
 
+export async function importViewsLayersGroupLayerView(): Promise<typeof __esri.GroupLayerView> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/views/layers/GroupLayerView");
+  }
+  const module = await import("@arcgis/core/views/layers/GroupLayerView.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newViewsLayersGroupLayerView(properties: __esri.GroupLayerViewProperties): Promise<__esri.GroupLayerView> {
+  const ModConstructor = await importViewsLayersGroupLayerView();
+  return new ModConstructor(properties);
+}
+
 export async function importViewsLayersImageryLayerView(): Promise<typeof __esri.ImageryLayerView> {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/layers/ImageryLayerView");
@@ -6736,6 +6996,19 @@ export async function newViewsLayersViewshedLayerView(properties: __esri.Viewshe
   return new ModConstructor(properties);
 }
 
+export async function importViewsLinkChartView(): Promise<typeof __esri.LinkChartView> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/views/LinkChartView");
+  }
+  const module = await import("@arcgis/core/views/LinkChartView.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newViewsLinkChartView(properties: __esri.LinkChartViewProperties): Promise<__esri.LinkChartView> {
+  const ModConstructor = await importViewsLinkChartView();
+  return new ModConstructor(properties);
+}
+
 export async function importViewsMagnifier(): Promise<typeof __esri.Magnifier> {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/Magnifier");
@@ -7126,6 +7399,19 @@ export async function newWebDocument2D(properties: __esri.WebDocument2DPropertie
   return new ModConstructor(properties);
 }
 
+export async function importWebLinkChart(): Promise<typeof __esri.WebLinkChart> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/WebLinkChart");
+  }
+  const module = await import("@arcgis/core/WebLinkChart.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newWebLinkChart(properties: __esri.WebLinkChartProperties): Promise<__esri.WebLinkChart> {
+  const ModConstructor = await importWebLinkChart();
+  return new ModConstructor(properties);
+}
+
 export async function importWebMap(): Promise<typeof __esri.WebMap> {
   if (isAMD) {
     return await window.$arcgis.import("esri/WebMap");
@@ -8192,6 +8478,32 @@ export async function newWidgetsFeatureFormRelationshipInput(properties: __esri.
   return new ModConstructor(properties);
 }
 
+export async function importWidgetsFeatureFormTextElementInput(): Promise<typeof __esri.TextElementInput> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/widgets/FeatureForm/TextElementInput");
+  }
+  const module = await import("@arcgis/core/widgets/FeatureForm/TextElementInput.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newWidgetsFeatureFormTextElementInput(properties: __esri.TextElementInputProperties): Promise<__esri.TextElementInput> {
+  const ModConstructor = await importWidgetsFeatureFormTextElementInput();
+  return new ModConstructor(properties);
+}
+
+export async function importWidgetsFeatureFormUtilityNetworkAssociationInput(): Promise<typeof __esri.UtilityNetworkAssociationInput> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/widgets/FeatureForm/UtilityNetworkAssociationInput");
+  }
+  const module = await import("@arcgis/core/widgets/FeatureForm/UtilityNetworkAssociationInput.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newWidgetsFeatureFormUtilityNetworkAssociationInput(properties: __esri.UtilityNetworkAssociationInputProperties): Promise<__esri.UtilityNetworkAssociationInput> {
+  const ModConstructor = await importWidgetsFeatureFormUtilityNetworkAssociationInput();
+  return new ModConstructor(properties);
+}
+
 export async function importWidgetsFeatures(): Promise<typeof __esri.Features> {
   if (isAMD) {
     return await window.$arcgis.import("esri/widgets/Features");
@@ -8400,6 +8712,32 @@ export async function newWidgetsFeatureTableSupportFieldColumnTemplate(propertie
   return new ModConstructor(properties);
 }
 
+export async function importWidgetsFeatureTableSupportAttachmentsColumnTemplate(): Promise<typeof __esri.AttachmentsColumnTemplate> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/widgets/FeatureTable/support/AttachmentsColumnTemplate");
+  }
+  const module = await import("@arcgis/core/widgets/FeatureTable/support/AttachmentsColumnTemplate.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newWidgetsFeatureTableSupportAttachmentsColumnTemplate(properties: __esri.AttachmentsColumnTemplateProperties): Promise<__esri.AttachmentsColumnTemplate> {
+  const ModConstructor = await importWidgetsFeatureTableSupportAttachmentsColumnTemplate();
+  return new ModConstructor(properties);
+}
+
+export async function importWidgetsFeatureTableSupportRelationshipColumnTemplate(): Promise<typeof __esri.RelationshipColumnTemplate> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/widgets/FeatureTable/support/RelationshipColumnTemplate");
+  }
+  const module = await import("@arcgis/core/widgets/FeatureTable/support/RelationshipColumnTemplate.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newWidgetsFeatureTableSupportRelationshipColumnTemplate(properties: __esri.RelationshipColumnTemplateProperties): Promise<__esri.RelationshipColumnTemplate> {
+  const ModConstructor = await importWidgetsFeatureTableSupportRelationshipColumnTemplate();
+  return new ModConstructor(properties);
+}
+
 export async function importWidgetsFeatureTableSupportGroupColumnTemplate(): Promise<typeof __esri.GroupColumnTemplate> {
   if (isAMD) {
     return await window.$arcgis.import("esri/widgets/FeatureTable/support/GroupColumnTemplate");
@@ -9648,6 +9986,19 @@ export async function newWidgetsUtilityNetworkTrace(properties: __esri.UtilityNe
   return new ModConstructor(properties);
 }
 
+export async function importWidgetsUtilityNetworkTraceAnalysisUtilityNetworkTraceAnalysisViewModel(): Promise<typeof __esri.UtilityNetworkTraceAnalysisViewModel> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/widgets/UtilityNetworkTraceAnalysis/UtilityNetworkTraceAnalysisViewModel");
+  }
+  const module = await import("@arcgis/core/widgets/UtilityNetworkTraceAnalysis/UtilityNetworkTraceAnalysisViewModel.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function newWidgetsUtilityNetworkTraceAnalysisUtilityNetworkTraceAnalysisViewModel(properties: any): Promise<__esri.UtilityNetworkTraceAnalysisViewModel> {
+  const ModConstructor = await importWidgetsUtilityNetworkTraceAnalysisUtilityNetworkTraceAnalysisViewModel();
+  return new ModConstructor(properties);
+}
+
 export async function importWidgetsUtilityNetworkTraceUtilityNetworkTraceViewModel(): Promise<typeof __esri.UtilityNetworkTraceViewModel> {
   if (isAMD) {
     return await window.$arcgis.import("esri/widgets/UtilityNetworkTrace/UtilityNetworkTraceViewModel");
@@ -9944,27 +10295,19 @@ export async function importCoreWorkers(): Promise<typeof __esri.workers> {
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importFormElementsInputsAttachmentsSupportInputs(): Promise<typeof __esri.inputs> {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/form/elements/inputs/attachments/support/inputs");
-  }
-  const module = await import("@arcgis/core/form/elements/inputs/attachments/support/inputs.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-
-export async function importFormElementsSupportInputs(): Promise<typeof __esri.supportInputs> {
+export async function importFormElementsInputs(): Promise<typeof __esri.inputs> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/form/elements/support/inputs");
+    return await window.$arcgis.import("esri/form/elements/inputs");
   }
-  const module = await import("@arcgis/core/form/elements/support/inputs.js");
+  const module = await import("@arcgis/core/form/elements/inputs.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importFormSupportElements(): Promise<typeof __esri.elements> {
+export async function importFormElements(): Promise<typeof __esri.elements> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/form/support/elements");
+    return await window.$arcgis.import("esri/form/elements");
   }
-  const module = await import("@arcgis/core/form/support/elements.js");
+  const module = await import("@arcgis/core/form/elements.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
@@ -10008,6 +10351,54 @@ export async function importGeometryProjection(): Promise<typeof __esri.projecti
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsAffineTransformOperator(): Promise<typeof __esri.affineTransformOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/affineTransformOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/affineTransformOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsAlphaShapeOperator(): Promise<typeof __esri.alphaShapeOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/alphaShapeOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/alphaShapeOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsAreaOperator(): Promise<typeof __esri.areaOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/areaOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/areaOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsAutoCompleteOperator(): Promise<typeof __esri.autoCompleteOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/autoCompleteOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/autoCompleteOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsBoundaryOperator(): Promise<typeof __esri.boundaryOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/boundaryOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/boundaryOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsBufferOperator(): Promise<typeof __esri.bufferOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/bufferOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/bufferOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsCentroidOperator(): Promise<typeof __esri.centroidOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/centroidOperator");
@@ -10024,19 +10415,19 @@ export async function importGeometryOperatorsClipOperator(): Promise<typeof __es
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importGeometryOperatorsCutOperator(): Promise<typeof __esri.cutOperator> {
+export async function importGeometryOperatorsContainsOperator(): Promise<typeof __esri.containsOperator> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/geometry/operators/cutOperator");
+    return await window.$arcgis.import("esri/geometry/operators/containsOperator");
   }
-  const module = await import("@arcgis/core/geometry/operators/cutOperator.js");
+  const module = await import("@arcgis/core/geometry/operators/containsOperator.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importGeometryOperatorsContainsOperator(): Promise<typeof __esri.containsOperator> {
+export async function importGeometryOperatorsConvexHullOperator(): Promise<typeof __esri.convexHullOperator> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/geometry/operators/containsOperator");
+    return await window.$arcgis.import("esri/geometry/operators/convexHullOperator");
   }
-  const module = await import("@arcgis/core/geometry/operators/containsOperator.js");
+  const module = await import("@arcgis/core/geometry/operators/convexHullOperator.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
@@ -10048,6 +10439,14 @@ export async function importGeometryOperatorsCrossesOperator(): Promise<typeof _
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsCutOperator(): Promise<typeof __esri.cutOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/cutOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/cutOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsDensifyOperator(): Promise<typeof __esri.densifyOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/densifyOperator");
@@ -10064,19 +10463,19 @@ export async function importGeometryOperatorsDifferenceOperator(): Promise<typeo
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importGeometryOperatorsDistanceOperator(): Promise<typeof __esri.distanceOperator> {
+export async function importGeometryOperatorsDisjointOperator(): Promise<typeof __esri.disjointOperator> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/geometry/operators/distanceOperator");
+    return await window.$arcgis.import("esri/geometry/operators/disjointOperator");
   }
-  const module = await import("@arcgis/core/geometry/operators/distanceOperator.js");
+  const module = await import("@arcgis/core/geometry/operators/disjointOperator.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importGeometryOperatorsDisjointOperator(): Promise<typeof __esri.disjointOperator> {
+export async function importGeometryOperatorsDistanceOperator(): Promise<typeof __esri.distanceOperator> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/geometry/operators/disjointOperator");
+    return await window.$arcgis.import("esri/geometry/operators/distanceOperator");
   }
-  const module = await import("@arcgis/core/geometry/operators/disjointOperator.js");
+  const module = await import("@arcgis/core/geometry/operators/distanceOperator.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
@@ -10088,6 +10487,22 @@ export async function importGeometryOperatorsEqualsOperator(): Promise<typeof __
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsExtendOperator(): Promise<typeof __esri.extendOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/extendOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/extendOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsGeneralizeOperator(): Promise<typeof __esri.generalizeOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/generalizeOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/generalizeOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsGeodesicBufferOperator(): Promise<typeof __esri.geodesicBufferOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/geodesicBufferOperator");
@@ -10096,6 +10511,22 @@ export async function importGeometryOperatorsGeodesicBufferOperator(): Promise<t
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsGeodesicProximityOperator(): Promise<typeof __esri.geodesicProximityOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/geodesicProximityOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/geodesicProximityOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsGeodeticAreaOperator(): Promise<typeof __esri.geodeticAreaOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/geodeticAreaOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/geodeticAreaOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsGeodeticDensifyOperator(): Promise<typeof __esri.geodeticDensifyOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/geodeticDensifyOperator");
@@ -10112,11 +10543,27 @@ export async function importGeometryOperatorsGeodeticDistanceOperator(): Promise
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importGeometryOperatorsGeneralizeOperator(): Promise<typeof __esri.generalizeOperator> {
+export async function importGeometryOperatorsGeodeticLengthOperator(): Promise<typeof __esri.geodeticLengthOperator> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/geometry/operators/generalizeOperator");
+    return await window.$arcgis.import("esri/geometry/operators/geodeticLengthOperator");
   }
-  const module = await import("@arcgis/core/geometry/operators/generalizeOperator.js");
+  const module = await import("@arcgis/core/geometry/operators/geodeticLengthOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsGraphicBufferOperator(): Promise<typeof __esri.graphicBufferOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/graphicBufferOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/graphicBufferOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsIntegrateOperator(): Promise<typeof __esri.integrateOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/integrateOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/integrateOperator.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
@@ -10136,6 +10583,70 @@ export async function importGeometryOperatorsIntersectsOperator(): Promise<typeo
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsIsNearOperator(): Promise<typeof __esri.isNearOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/isNearOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/isNearOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsLabelPointOperator(): Promise<typeof __esri.labelPointOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/labelPointOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/labelPointOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsLengthOperator(): Promise<typeof __esri.lengthOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/lengthOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/lengthOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsLinesToPolygonsOperator(): Promise<typeof __esri.linesToPolygonsOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/linesToPolygonsOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/linesToPolygonsOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsLocateBetweenOperator(): Promise<typeof __esri.locateBetweenOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/locateBetweenOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/locateBetweenOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsMinimumBoundingCircleOperator(): Promise<typeof __esri.minimumBoundingCircleOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/minimumBoundingCircleOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/minimumBoundingCircleOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsMultiPartToSinglePartOperator(): Promise<typeof __esri.multiPartToSinglePartOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/multiPartToSinglePartOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/multiPartToSinglePartOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsOffsetOperator(): Promise<typeof __esri.offsetOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/offsetOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/offsetOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsOverlapsOperator(): Promise<typeof __esri.overlapsOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/overlapsOperator");
@@ -10144,6 +10655,22 @@ export async function importGeometryOperatorsOverlapsOperator(): Promise<typeof
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsPolygonOverlayOperator(): Promise<typeof __esri.polygonOverlayOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/polygonOverlayOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/polygonOverlayOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importGeometryOperatorsPolygonSlicerOperator(): Promise<typeof __esri.polygonSlicerOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/polygonSlicerOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/polygonSlicerOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsProximityOperator(): Promise<typeof __esri.proximityOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/proximityOperator");
@@ -10160,6 +10687,14 @@ export async function importGeometryOperatorsRelateOperator(): Promise<typeof __
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsReshapeOperator(): Promise<typeof __esri.reshapeOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/reshapeOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/reshapeOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsSimplifyOperator(): Promise<typeof __esri.simplifyOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/simplifyOperator");
@@ -10168,6 +10703,14 @@ export async function importGeometryOperatorsSimplifyOperator(): Promise<typeof
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importGeometryOperatorsSymmetricDifferenceOperator(): Promise<typeof __esri.symmetricDifferenceOperator> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/geometry/operators/symmetricDifferenceOperator");
+  }
+  const module = await import("@arcgis/core/geometry/operators/symmetricDifferenceOperator.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importGeometryOperatorsTouchesOperator(): Promise<typeof __esri.touchesOperator> {
   if (isAMD) {
     return await window.$arcgis.import("esri/geometry/operators/touchesOperator");
@@ -10256,6 +10799,22 @@ export async function importLayersCatalogCatalogUtils(): Promise<typeof __esri.c
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importLayersKnowledgeGraphCypherUtils(): Promise<typeof __esri.cypherUtils> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/knowledgeGraph/cypherUtils");
+  }
+  const module = await import("@arcgis/core/layers/knowledgeGraph/cypherUtils.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importLayersKnowledgeGraphSupportUtils(): Promise<typeof __esri.supportUtils> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/knowledgeGraph/supportUtils");
+  }
+  const module = await import("@arcgis/core/layers/knowledgeGraph/supportUtils.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importLayersOgcWfsUtils(): Promise<typeof __esri.wfsUtils> {
   if (isAMD) {
     return await window.$arcgis.import("esri/layers/ogc/wfsUtils");
@@ -10264,6 +10823,30 @@ export async function importLayersOgcWfsUtils(): Promise<typeof __esri.wfsUtils>
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importLayersOgcWcsUtils(): Promise<typeof __esri.wcsUtils> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/ogc/wcsUtils");
+  }
+  const module = await import("@arcgis/core/layers/ogc/wcsUtils.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importLayersOrientedImageryTransformationsWorldToImage(): Promise<typeof __esri.worldToImage> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/orientedImagery/transformations/worldToImage");
+  }
+  const module = await import("@arcgis/core/layers/orientedImagery/transformations/worldToImage.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importLayersOrientedImageryTransformationsImageToWorld(): Promise<typeof __esri.imageToWorld> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/orientedImagery/transformations/imageToWorld");
+  }
+  const module = await import("@arcgis/core/layers/orientedImagery/transformations/imageToWorld.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importLayersSupportArcadeUtils(): Promise<typeof __esri.arcadeUtils> {
   if (isAMD) {
     return await window.$arcgis.import("esri/layers/support/arcadeUtils");
@@ -10680,7 +11263,7 @@ export async function importSmartMappingRasterSupportColorRamps(): Promise<typeo
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importSmartMappingRasterSupportUtils(): Promise<typeof __esri.supportUtils> {
+export async function importSmartMappingRasterSupportUtils(): Promise<typeof __esri.rasterSupportUtils> {
   if (isAMD) {
     return await window.$arcgis.import("esri/smartMapping/raster/support/utils");
   }
@@ -10776,6 +11359,14 @@ export async function importSmartMappingRenderersUnivariateColorSize(): Promise<
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importSmartMappingRenderersSupportRendererUtils(): Promise<typeof __esri.rendererUtils> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/smartMapping/renderers/support/rendererUtils");
+  }
+  const module = await import("@arcgis/core/smartMapping/renderers/support/rendererUtils.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importSmartMappingStatisticsClassBreaks(): Promise<typeof __esri.statisticsClassBreaks> {
   if (isAMD) {
     return await window.$arcgis.import("esri/smartMapping/statistics/classBreaks");
@@ -10992,11 +11583,11 @@ export async function importSymbolsSupportSymbolUtils(): Promise<typeof __esri.s
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importTablesSupportElements(): Promise<typeof __esri.supportElements> {
+export async function importTablesElements(): Promise<typeof __esri.tablesElements> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/tables/support/elements");
+    return await window.$arcgis.import("esri/tables/elements");
   }
-  const module = await import("@arcgis/core/tables/support/elements.js");
+  const module = await import("@arcgis/core/tables/elements.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
@@ -11016,14 +11607,6 @@ export async function importVersionManagementVersionAdaptersUtils(): Promise<typ
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importViews3dExternalRenderers(): Promise<typeof __esri.externalRenderers> {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/views/3d/externalRenderers");
-  }
-  const module = await import("@arcgis/core/views/3d/externalRenderers.js");
-  return isDefaultModule(module) ? module.default : module;
-}
-
 export async function importViews3dWebglManagedFBO(): Promise<typeof __esri.ManagedFBO> {
   if (isAMD) {
     return await window.$arcgis.import("esri/views/3d/webgl/ManagedFBO");
@@ -11088,6 +11671,14 @@ export async function importWidgetsBatchAttributeFormBatchAttributeFormViewModel
   return isDefaultModule(module) ? module.default : module;
 }
 
+export async function importWidgetsFeatureFeatureUtilityNetworkAssociationsFeatureUtilityNetworkAssociationsViewModel(): Promise<typeof __esri.FeatureUtilityNetworkAssociationsViewModel> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/widgets/Feature/FeatureUtilityNetworkAssociations/FeatureUtilityNetworkAssociationsViewModel");
+  }
+  const module = await import("@arcgis/core/widgets/Feature/FeatureUtilityNetworkAssociations/FeatureUtilityNetworkAssociationsViewModel.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
 export async function importWidgetsSmartMappingSupportUtils(): Promise<typeof __esri.smartMappingSupportUtils> {
   if (isAMD) {
     return await window.$arcgis.import("esri/widgets/smartMapping/support/utils");
@@ -11104,83 +11695,99 @@ export async function importWidgetsSupportWidget(): Promise<typeof __esri.widget
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsWebEditorSketchUtils(): Promise<typeof __esri.sketchUtils> {
+export async function importApplicationsComponentsBasemapUtils(): Promise<typeof __esri.basemapUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/WebEditor/sketchUtils");
+    return await window.$arcgis.import("esri/applications/Components/basemapUtils");
   }
-  const module = await import("@arcgis/core/applications/WebEditor/sketchUtils.js");
+  const module = await import("@arcgis/core/applications/Components/basemapUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsSceneViewerSymbolUtils(): Promise<typeof __esri.SceneViewerSymbolUtils> {
+export async function importApplicationsComponentsCollectionFlattener(): Promise<any> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/SceneViewer/symbolUtils");
+    return await window.$arcgis.import("esri/applications/Components/CollectionFlattener");
   }
-  const module = await import("@arcgis/core/applications/SceneViewer/symbolUtils.js");
+  const module = await import("@arcgis/core/applications/Components/CollectionFlattener.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsSceneViewerSceneViewerUtils(): Promise<typeof __esri.sceneViewerUtils> {
+export async function importApplicationsComponentsDrawUtils(): Promise<typeof __esri.drawUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/SceneViewer/sceneViewerUtils");
+    return await window.$arcgis.import("esri/applications/Components/drawUtils");
   }
-  const module = await import("@arcgis/core/applications/SceneViewer/sceneViewerUtils.js");
+  const module = await import("@arcgis/core/applications/Components/drawUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsSceneViewerLayerUtils(): Promise<typeof __esri.layerUtils> {
+export async function importApplicationsComponentsFontUtils(): Promise<typeof __esri.fontUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/SceneViewer/layerUtils");
+    return await window.$arcgis.import("esri/applications/Components/fontUtils");
   }
-  const module = await import("@arcgis/core/applications/SceneViewer/layerUtils.js");
+  const module = await import("@arcgis/core/applications/Components/fontUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsSceneViewerDevEnvironmentUtils(): Promise<typeof __esri.devEnvironmentUtils> {
+export async function importApplicationsComponentsGetDefaultUnits(): Promise<typeof __esri.getDefaultUnits> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/SceneViewer/devEnvironmentUtils");
+    return await window.$arcgis.import("esri/applications/Components/getDefaultUnits");
   }
-  const module = await import("@arcgis/core/applications/SceneViewer/devEnvironmentUtils.js");
+  const module = await import("@arcgis/core/applications/Components/getDefaultUnits.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsSceneViewerColorUtils(): Promise<typeof __esri.SceneViewerColorUtils> {
+export async function importApplicationsComponentsGfxUtils(): Promise<typeof __esri.gfxUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/SceneViewer/colorUtils");
+    return await window.$arcgis.import("esri/applications/Components/gfxUtils");
   }
-  const module = await import("@arcgis/core/applications/SceneViewer/colorUtils.js");
+  const module = await import("@arcgis/core/applications/Components/gfxUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsMapViewerMediaUtils(): Promise<typeof __esri.mediaUtils> {
+export async function importApplicationsComponentsLayerOriginUtils(): Promise<typeof __esri.layerOriginUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/MapViewer/mediaUtils");
+    return await window.$arcgis.import("esri/applications/Components/layerOriginUtils");
   }
-  const module = await import("@arcgis/core/applications/MapViewer/mediaUtils.js");
+  const module = await import("@arcgis/core/applications/Components/layerOriginUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsExcaliburVideoViewUtils(): Promise<typeof __esri.videoViewUtils> {
+export async function importApplicationsComponentsLayersEffectsJsonUtils(): Promise<typeof __esri.layersEffectsJsonUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Excalibur/videoViewUtils");
+    return await window.$arcgis.import("esri/applications/Components/layersEffectsJsonUtils");
   }
-  const module = await import("@arcgis/core/applications/Excalibur/videoViewUtils.js");
+  const module = await import("@arcgis/core/applications/Components/layersEffectsJsonUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsWebStyleSymbolUtils(): Promise<typeof __esri.webStyleSymbolUtils> {
+export async function importApplicationsComponentsPreviewSymbol2D(): Promise<typeof __esri.previewSymbol2D> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/webStyleSymbolUtils");
+    return await window.$arcgis.import("esri/applications/Components/previewSymbol2D");
   }
-  const module = await import("@arcgis/core/applications/Components/webStyleSymbolUtils.js");
+  const module = await import("@arcgis/core/applications/Components/previewSymbol2D.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsSvgUtils(): Promise<typeof __esri.svgUtils> {
+export async function importApplicationsComponentsReactiveUtils(): Promise<typeof __esri.ComponentsReactiveUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/svgUtils");
+    return await window.$arcgis.import("esri/applications/Components/reactiveUtils");
   }
-  const module = await import("@arcgis/core/applications/Components/svgUtils.js");
+  const module = await import("@arcgis/core/applications/Components/reactiveUtils.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importApplicationsComponentsSelectionOperation(): Promise<any> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/applications/Components/SelectionOperation");
+  }
+  const module = await import("@arcgis/core/applications/Components/SelectionOperation.js");
+  return isDefaultModule(module) ? module.default : module;
+}
+
+export async function importApplicationsComponentsSketchTooltipControls(): Promise<any> {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/applications/Components/SketchTooltipControls");
+  }
+  const module = await import("@arcgis/core/applications/Components/SketchTooltipControls.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
@@ -11192,50 +11799,50 @@ export async function importApplicationsComponentsStyleUtils(): Promise<typeof _
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsPreviewSymbol2D(): Promise<typeof __esri.previewSymbol2D> {
+export async function importApplicationsComponentsSvgUtils(): Promise<typeof __esri.svgUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/previewSymbol2D");
+    return await window.$arcgis.import("esri/applications/Components/svgUtils");
   }
-  const module = await import("@arcgis/core/applications/Components/previewSymbol2D.js");
+  const module = await import("@arcgis/core/applications/Components/svgUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsLayerOriginUtils(): Promise<typeof __esri.layerOriginUtils> {
+export async function importApplicationsComponentsWebStyleSymbolUtils(): Promise<typeof __esri.webStyleSymbolUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/layerOriginUtils");
+    return await window.$arcgis.import("esri/applications/Components/webStyleSymbolUtils");
   }
-  const module = await import("@arcgis/core/applications/Components/layerOriginUtils.js");
+  const module = await import("@arcgis/core/applications/Components/webStyleSymbolUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsGfxUtils(): Promise<typeof __esri.gfxUtils> {
+export async function importApplicationsExperienceBuilderSketchUtils(): Promise<typeof __esri.sketchUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/gfxUtils");
+    return await window.$arcgis.import("esri/applications/ExperienceBuilder/sketchUtils");
   }
-  const module = await import("@arcgis/core/applications/Components/gfxUtils.js");
+  const module = await import("@arcgis/core/applications/ExperienceBuilder/sketchUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsGetDefaultUnits(): Promise<typeof __esri.getDefaultUnits> {
+export async function importApplicationsMapViewerTemplateUtils(): Promise<typeof __esri.templateUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/getDefaultUnits");
+    return await window.$arcgis.import("esri/applications/MapViewer/templateUtils");
   }
-  const module = await import("@arcgis/core/applications/Components/getDefaultUnits.js");
+  const module = await import("@arcgis/core/applications/MapViewer/templateUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsDrawUtils(): Promise<typeof __esri.drawUtils> {
+export async function importApplicationsSceneViewerDevEnvironmentUtils(): Promise<typeof __esri.devEnvironmentUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/drawUtils");
+    return await window.$arcgis.import("esri/applications/SceneViewer/devEnvironmentUtils");
   }
-  const module = await import("@arcgis/core/applications/Components/drawUtils.js");
+  const module = await import("@arcgis/core/applications/SceneViewer/devEnvironmentUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }
 
-export async function importApplicationsComponentsBasemapUtils(): Promise<typeof __esri.basemapUtils> {
+export async function importApplicationsWebEditorSketchUtils(): Promise<typeof __esri.WebEditorSketchUtils> {
   if (isAMD) {
-    return await window.$arcgis.import("esri/applications/Components/basemapUtils");
+    return await window.$arcgis.import("esri/applications/WebEditor/sketchUtils");
   }
-  const module = await import("@arcgis/core/applications/Components/basemapUtils.js");
+  const module = await import("@arcgis/core/applications/WebEditor/sketchUtils.js");
   return isDefaultModule(module) ? module.default : module;
 }