@conterra/ct-mapapps-typings 4.20.1 → 4.20.2

package/agssearch/api.d.ts

@@ -1,5 +1,5 @@
-import Layer from 'esri/layers/Layer';
-import Sublayer from 'esri/layers/support/Sublayer';
+import Layer from '@arcgis/core/layers/Layer';
+import Sublayer from '@arcgis/core/layers/support/Sublayer';
 import { AsyncStore } from 'store-api/api';
 
 /**

package/agssearch/package.json

@@ -1,5 +1,5 @@
 {
     "name": "agssearch",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/apprt/Bundle.d.ts

@@ -1,4 +1,4 @@
-import { BundleManifestEntries, BundleManifestJson, BundleStates, BundleId, Bundle, BundleState, BundleStateName, SemVer, BundleContext, I18N, ServiceReference, BundleDependency, BundleHeaders } from './api/index.js';
+import { BundleManifestEntries, BundleManifestJson, BundleStates, BundleId, Bundle, BundleState, BundleStateName, SemVer, BundleContext, BundleHeaders, I18N, ServiceReference, BundleDependency } from './api/index.js';
 import { InternalBundle, InternalBundleController, InternalBundleContext } from './api/internal.js';
 import 'apprt-core/Types';
 

package/apprt/EnvironmentRuleMatcher.d.ts

@@ -46,4 +46,5 @@ declare function createEnvironmentRuleMatcher(opts: {
     };
 }): EnvironmentRuleMatcher;
 
-export { type EnvironmentRuleMatcher, type ORIENTATION, createEnvironmentRuleMatcher as default };
+export { createEnvironmentRuleMatcher as default };
+export type { EnvironmentRuleMatcher, ORIENTATION };

package/apprt/api/index.d.ts

@@ -1348,6 +1348,7 @@ interface AppConfigJson {
         preFetchMain?: boolean;
         preFetchCompressedVersions?: boolean;
         prefetchSecondAggregate?: boolean | number;
+        prefetchSecondNonBlocking?: boolean;
     };
     bundles?: Record<string, boolean | Record<string, any>>;
 }

package/apprt/api/internal.d.ts

@@ -1,4 +1,4 @@
-import { ServiceRegistration, Bundle, ServiceReference, Filter, BundleContext, BundleState, I18N, Framework, BundleId, BundleManifestJson, ServiceInstance, ServiceProperties, BundleEventListener, EventHandle, FrameworkEventListener, ServiceEventListener, ExecutionEnvironment, FrameworkEvent, ServiceEvent, AppConfigJson, BundleManifestJson3x } from './index.js';
+import { AppConfigJson, BundleManifestJson, BundleManifestJson3x, I18N, Filter, BundleId, Bundle, Framework, ServiceReference, ServiceInstance, ServiceProperties, ServiceRegistration, BundleEventListener, EventHandle, FrameworkEventListener, ServiceEventListener, ExecutionEnvironment, FrameworkEvent, ServiceEvent, BundleState, BundleContext } from './index.js';
 import 'apprt-core/Types';
 
 interface InternalServiceRegistration extends ServiceRegistration {
@@ -139,7 +139,7 @@ interface BundleLoadSuccess {
     manifest: BundleManifestJson;
     location: string;
     locationroot: PackageLocationDefinition;
-    error: undefined;
+    error?: undefined;
 }
 interface BundleLoadError {
     error: Error;

package/apprt/launch/BundleController.d.ts

@@ -1,10 +1,11 @@
 import { I18N, Filter, BundleId, BundleManifestJson, Framework, Bundle, FrameworkEvent, ServiceEvent, ServiceInstance, ServiceProperties, ServiceRegistration, ServiceReference, BundleEventListener, EventHandle, FrameworkEventListener, ServiceEventListener, ExecutionEnvironment } from '../api/index.js';
-import { Statistics, InternalBundleController, InternalBundle, InternalFramework } from '../api/internal.js';
+import { InternalBundleController, Statistics, InternalBundle, InternalFramework } from '../api/internal.js';
 import 'apprt-core/Types';
 
 interface BundleControllerConstructorOptions {
     statistics?: Statistics | undefined;
 }
+declare function setChangeRequire(change: boolean): void;
 declare class BundleControllerImpl implements InternalBundleController {
     private _bundles;
     private _bundleNamesToIds;
@@ -77,4 +78,5 @@ declare class BundleControllerImpl implements InternalBundleController {
 type AnyFunc = (...args: any[]) => any;
 declare function bind(scope: any, fn: string | AnyFunc): AnyFunc;
 
-export { type BundleControllerConstructorOptions, bind, BundleControllerImpl as default };
+export { bind, BundleControllerImpl as default, setChangeRequire };
+export type { BundleControllerConstructorOptions };

package/apprt/launch/Launcher.d.ts

@@ -1,5 +1,5 @@
-import { LocationDefinition, Launcher, LauncherOptions, Framework } from '../api/index.js';
-import { BundleLocator, ConfigLocator } from '../api/internal.js';
+import { Launcher, LocationDefinition, LauncherOptions, Framework, Bundle } from '../api/index.js';
+import { BundleLocator, ConfigLocator, BundleLoadSuccess } from '../api/internal.js';
 import 'apprt-core/Types';
 
 interface LauncherConstructorOptions {
@@ -22,6 +22,23 @@ interface LauncherConstructorOptions {
     writeError?: boolean;
     enableStatistics?: boolean;
 }
+interface BundleInfo extends BundleLoadSuccess {
+    installedBundle?: Bundle;
+}
+interface PreFetchDef {
+    locName: string;
+    skip: boolean;
+    url?: string;
+    static: boolean;
+    mids: MidInfo[];
+    skipMids: MidInfo[];
+    transitive: boolean;
+}
+interface MidInfo {
+    bundle: string;
+    version: string;
+    file: string;
+}
 declare class LauncherImpl implements Launcher {
     private _query;
     private _locations;
@@ -50,10 +67,12 @@ declare class LauncherImpl implements Launcher {
     private _locateBundles;
     private _prefetchBundles;
     private _prefetch;
+    _splitPrefetchBundles(preFetchesArr: PreFetchDef[], preFetchCompressedVersions: boolean, preFetchWithGzip: boolean, maxUrlLength: number, installedBundles: BundleInfo[]): Promise<PreFetchDef[]>;
     private _installFramework;
     private _initializeFramework;
     private _startFramework;
     private _prefetchRemaining;
+    private _preFetchSecond;
     private _installBundles;
     private _filterSuccessBundles;
     private _getBundlesToInstall;
@@ -69,4 +88,5 @@ declare class LauncherImpl implements Launcher {
     private _queryParams;
 }
 
-export { type LauncherConstructorOptions, LauncherImpl as default };
+export { LauncherImpl as default };
+export type { LauncherConstructorOptions };

package/apprt/launch/layer-min.d.ts

@@ -1,2 +1,2 @@
 
-export {  }
+export { };

package/apprt/launch/layer.d.ts

@@ -1,2 +1,2 @@
 
-export {  }
+export { };

package/apprt/package.json

@@ -1,5 +1,5 @@
 {
     "name": "apprt",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/apprt/semverrange.d.ts

@@ -89,4 +89,5 @@ interface BundleRange {
 }
 declare function parseBundleRange(nameWithRange: string): BundleRange;
 
-export { type BundleRange, semverrange as default, parseBundleRange };
+export { semverrange as default, parseBundleRange };
+export type { BundleRange };

package/apprt/support/ServiceRegistrations.d.ts

@@ -1,4 +1,4 @@
-import { ServiceProperties, BundleContext } from '../api/index.js';
+import { BundleContext, ServiceProperties } from '../api/index.js';
 import 'apprt-core/Types';
 
 interface ServiceRegistrationItem<T = unknown> {
@@ -14,4 +14,5 @@ interface ServiceRegistrations {
 }
 declare function Factory(bCtx: BundleContext): ServiceRegistrations;
 
-export { type ServiceRegistrationItem, type ServiceRegistrations, Factory as default };
+export { Factory as default };
+export type { ServiceRegistrationItem, ServiceRegistrations };

package/apprt/tracker/BundleTracker.d.ts

@@ -34,4 +34,5 @@ interface BundleTrackerOptions<ObjectType> {
 }
 declare function createBundleTracker<ObjectType = Bundle>(opts: BundleTrackerOptions<ObjectType>): BundleTracker<ObjectType>;
 
-export { type BundleTracker, type BundleTrackerCustomizer, type BundleTrackerOptions, createBundleTracker, createBundleTracker as default };
+export { createBundleTracker, createBundleTracker as default };
+export type { BundleTracker, BundleTrackerCustomizer, BundleTrackerOptions };

package/apprt/tracker/ServiceTracker.d.ts

@@ -1,4 +1,4 @@
-import { ServiceReference, ServiceEvent, BundleContext } from '../api/index.js';
+import { BundleContext, ServiceReference, ServiceEvent } from '../api/index.js';
 import 'apprt-core/Types';
 
 interface ServiceTrackerCustomizer<ServiceType> {
@@ -39,4 +39,5 @@ interface ServiceTracker<ServiceType> {
 }
 declare function createServiceTracker<ServiceType>(opts: ServiceTrackerOptions<ServiceType>): ServiceTracker<ServiceType>;
 
-export { type ServiceTracker, type ServiceTrackerCustomizer, type ServiceTrackerOptions, createServiceTracker, createServiceTracker as default };
+export { createServiceTracker, createServiceTracker as default };
+export type { ServiceTracker, ServiceTrackerCustomizer, ServiceTrackerOptions };

package/apprt-binding/Binding.d.ts

@@ -308,4 +308,5 @@ interface Binding<LeftPropName extends PropertyName = string, RightPropName exte
  */
 declare const Binding: Factory;
 
-export { type Bindable, type BindableInterface, Binding, type Context, type ConvertFunction, type Factory, type PropertyName, type WatchCallback, type WatchHandle, Binding as default };
+export { Binding, Binding as default };
+export type { Bindable, BindableInterface, Context, ConvertFunction, Factory, PropertyName, WatchCallback, WatchHandle };

package/apprt-binding/Transformers.d.ts

@@ -122,4 +122,5 @@ declare function instance(callback?: Transformer): Transformer;
  */
 declare function prop(name: string, callback?: Transformer): Transformer;
 
-export { type Transformer, type TransformerWithElse, debounce, debounceOrCancel, deferOrCancel, ifDefined, ifTargetNotEqualsAlmost, instance, prop };
+export { debounce, debounceOrCancel, deferOrCancel, ifDefined, ifTargetNotEqualsAlmost, instance, prop };
+export type { Transformer, TransformerWithElse };

package/apprt-binding/package.json

@@ -1,5 +1,5 @@
 {
     "name": "apprt-binding",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/apprt-core/AsyncTask.d.ts

@@ -54,4 +54,5 @@ declare function createTask<Args extends any[], Result>(callback: (...args: Args
  */
 declare function createTask(): Task<[], void>;
 
-export { type Task, createTask, createTask as default };
+export { createTask, createTask as default };
+export type { Task };

package/apprt-core/Cancel.d.ts

@@ -44,4 +44,5 @@ declare const Cancel: CancelConstructor;
  */
 declare function isCancellationError(error: any): boolean;
 
-export { Cancel, type CancelConstructor, Cancel as default, isCancellationError };
+export { Cancel, Cancel as default, isCancellationError };
+export type { CancelConstructor };

package/apprt-core/CancelablePromise.d.ts

@@ -45,4 +45,5 @@ declare class CancelablePromise<T> extends ExtendedPromise<T> {
     static cancelable<T>(promise: PromiseLike<T>): CancelablePromise<T>;
 }
 
-export { CancelablePromise, type CancelablePromiseExecutor, CancelablePromise as default };
+export { CancelablePromise, CancelablePromise as default };
+export type { CancelablePromiseExecutor };

package/apprt-core/Events.d.ts

@@ -20,12 +20,42 @@ interface EventedConstructor {
     /** Creates a new Evented instance. */
     new <Events>(): Evented<Events>;
 }
+/** The signature of {@link Evented | Evented's} `on(...)` method. */
+interface EventedOn<Events> {
+    /**
+     * Register event listener for specific events.
+     *
+     * @param eventName name of the event
+     * @param callback the event handler callback will be invoked when the event has been emitted
+     * @returns a handle to unregister from the event
+     */
+    <Name extends EventNames<Events>>(eventName: Name, callback: EventCallback<Events[Name]>): EventHandle;
+    /**
+     * Register event listener for any event.
+     *
+     * @param eventName must be `"*"` for this overload
+     * @param callback the event handler callback will be invoked when any event has been emitted
+     * @returns a handle to unregister from the events
+     */
+    (eventName: "*", callback: EventCallback<Events[EventNames<Events>]>): EventHandle;
+    /**
+     * Register event listener for the events listed in `eventName`.
+     * Comma separated event names are possible, for example `"eventA,eventB"`.
+     *
+     * @param eventName the event name or list of names
+     * @param callback the event handler callback
+     * @returns a handle to unregister from the event(s)
+     */
+    (eventName: string | string[], callback: EventCallback<unknown>): EventHandle;
+}
 /**
  * Like `Evented`, but only specifies the `on` function.
  * This is useful if clients of a class should not be able to invoke the `emit()` function
  * themselves.
  */
-type EventSource<Events> = Pick<Evented<Events>, "on">;
+interface EventSource<Events> {
+    on: EventedOn<Events>;
+}
 /**
  * A helper object that establishes TypeScript support for arbitrary event targets.
  *
@@ -223,31 +253,7 @@ declare function cleanup(target: any): void;
  * ```
  */
 interface Evented<Events> {
-    /**
-     * Register event listener for specific events.
-     *
-     * @param eventName name of the event
-     * @param callback the event handler callback will be invoked when the event has been emitted
-     * @returns a handle to unregister from the event
-     */
-    on<Name extends EventNames<Events>>(eventName: Name, callback: EventCallback<Events[Name]>): EventHandle;
-    /**
-     * Register event listener for any event.
-     *
-     * @param eventName must be `"*"` for this overload
-     * @param callback the event handler callback will be invoked when any event has been emitted
-     * @returns a handle to unregister from the events
-     */
-    on(eventName: "*", callback: EventCallback<Events[EventNames<Events>]>): EventHandle;
-    /**
-     * Register event listener for the events listed in `eventName`.
-     * Comma separated event names are possible, for example `"eventA,eventB"`.
-     *
-     * @param eventName the event name or list of names
-     * @param callback the event handler callback
-     * @returns a handle to unregister from the event(s)
-     */
-    on(eventName: string | string[], callback: EventCallback<unknown>): EventHandle;
+    on: EventedOn<Events>;
     /**
      * Emits an event.
      * All associated event listeners registered for the given event name will be invoked asynchronously.
@@ -281,4 +287,5 @@ declare const Evented: EventedConstructor;
  */
 declare function EventedMixin<BaseType extends Constructor<any, any>>(Base: BaseType): Constructor<InstanceType<BaseType> & Evented<any>, ConstructorParameters<BaseType>>;
 
-export { type EventCallback, type EventHandle, type EventNames, type EventSource, Evented, type EventedConstructor, EventedMixin, EventedMixin as Evented_Mixin, type TypedEvents, cleanup, createTypedEvents, emit, emitSync, on };
+export { Evented, EventedMixin, EventedMixin as Evented_Mixin, cleanup, createTypedEvents, emit, emitSync, on };
+export type { EventCallback, EventHandle, EventNames, EventSource, EventedConstructor, EventedOn, TypedEvents };

package/apprt-core/Exception.d.ts

@@ -115,4 +115,5 @@ interface ExceptionConstructor {
     notImplemented(message: string, cause?: Error | Exception): Exception;
 }
 
-export { type BaseExceptionConstructor, Exception, type ExceptionConstructor, ExceptionNames, Exception as default, registerTypes };
+export { Exception, ExceptionNames, Exception as default, registerTypes };
+export type { BaseExceptionConstructor, ExceptionConstructor };

package/apprt-core/InjectedReference.d.ts

@@ -6,4 +6,5 @@
 type InjectedReference<T> = T | undefined;
 declare const _null: null;
 
-export { type InjectedReference, _null };
+export { _null };
+export type { InjectedReference };

package/apprt-core/Locale.d.ts

@@ -8,7 +8,6 @@ declare class Locale {
     /**
      * Creates a Locale
      *
-     * @constructs
      * @param lang The language or the full lang-country string.
      * @param country The country.
      */

package/apprt-core/Logger.d.ts

@@ -249,4 +249,5 @@ declare function setWriter(newWriter?: Writer): void;
  */
 declare function readConfigFromString(loggingConfStr?: string): [string, LogLevel][];
 
-export { type LogLevel, type Logger, type Writer, type WriterMethod, getLogConfig, getLogLevel, loggerForName, readConfigFromString, setLogConfig, setLogLevel, setWriter };
+export { getLogConfig, getLogLevel, loggerForName, readConfigFromString, setLogConfig, setLogLevel, setWriter };
+export type { LogLevel, Logger, Writer, WriterMethod };

package/apprt-core/Mutable.d.ts

@@ -296,4 +296,5 @@ declare function properties(clazzOrObject: any, definitions: Record<string | sym
  */
 declare function construct<T>(params: Record<string, unknown>, self: T): T;
 
-export { Mutable, type MutableConstructor, type MutableDefinition, type PropType, type Properties, type PropertyName, type WatchCallback, type WatchEvent, type WatchHandle, construct, declare, declare as default, notifyChange, properties, propertyNames, toObject };
+export { Mutable, construct, declare, declare as default, notifyChange, properties, propertyNames, toObject };
+export type { MutableConstructor, MutableDefinition, PropType, Properties, PropertyName, WatchCallback, WatchEvent, WatchHandle };

package/apprt-core/Observers.d.ts

@@ -191,4 +191,5 @@ interface ObserverOptions {
  */
 declare function createObservers(options?: ObserverOptions): Observers;
 
-export { type Handle, type HandleMethods, type ObserverGroup, type ObserverOptions, type Observers, type RebindCallback, createObservers, createObservers as default };
+export { createObservers, createObservers as default };
+export type { Handle, HandleMethods, ObserverGroup, ObserverOptions, Observers, RebindCallback };

package/apprt-core/Promise.d.ts

@@ -180,4 +180,5 @@ interface LegacyDojoDeferred {
     toString(): string;
 }
 
-export { ExtendedPromise, type StateQueryable, ExtendedPromise as default };
+export { ExtendedPromise, ExtendedPromise as default };
+export type { StateQueryable };

package/apprt-core/PropertyPath.d.ts

@@ -54,4 +54,5 @@ interface PathAccessor {
  */
 declare function PropertyPath(path?: string | symbol): PathAccessorFactory;
 
-export { type PathAccessor, type PathAccessorFactory, PropertyPath, PropertyPath as default };
+export { PropertyPath, PropertyPath as default };
+export type { PathAccessor, PathAccessorFactory };

package/apprt-core/TaskExecutor.d.ts

@@ -57,4 +57,5 @@ declare class TaskExecutor {
     remove(task: Partial<Task> | (() => void)): void;
 }
 
-export { type Task, TaskExecutor, TaskExecutor as default };
+export { TaskExecutor, TaskExecutor as default };
+export type { Task };

package/apprt-core/TreeWalker.d.ts

@@ -109,4 +109,5 @@ interface TreeWalkerInterface<NodeType extends Node> {
  */
 declare function TreeWalker<NodeType extends Node = Node>(options?: TreeWalkerOptions<NodeType>): TreeWalkerInterface<NodeType>;
 
-export { type Context, type Node, TreeWalker, type TreeWalkerInterface, type TreeWalkerOptions, VisitCodes, type Visitor, TreeWalker as default };
+export { TreeWalker, VisitCodes, TreeWalker as default };
+export type { Context, Node, TreeWalkerInterface, TreeWalkerOptions, Visitor };

package/apprt-core/Types.d.ts

@@ -100,7 +100,7 @@ type WatchCallback<NameType, ValueType> = (event: WatchEvent<NameType, ValueType
  * It matches the apprt-core/Mutable watch interface.
  */
 interface Watchable<WatchableProperties> {
-    watch<Name extends keyof WatchableProperties>(name: Name, callBack: WatchCallback<Name, WatchableProperties[Name]>): Handle;
+    watch<Name extends keyof WatchableProperties>(name: Name, callback: WatchCallback<Name, WatchableProperties[Name]>): Handle;
 }
 /**
  * Helper type to express a set of statically known values (with autocompletion) that can still be extended.
@@ -126,4 +126,5 @@ type ExtensibleUnion<Values extends BaseType, BaseType extends number | string>
 type Constructor<T, Args extends unknown[] = unknown[]> = new (...args: Args) => T;
 declare const _default: null;
 
-export { type Constructor, type DeepReadonly, type DeepWritable, type Equal, type EventCallback, type EventEmitter, type EventSource, type ExtensibleUnion, type Handle, type Primitive, type RequiredProps, type TupleKeys, type WatchCallback, type WatchEvent, type Watchable, type Writable, _default as default };
+export { _default as default };
+export type { Constructor, DeepReadonly, DeepWritable, Equal, EventCallback, EventEmitter, EventSource, ExtensibleUnion, Handle, Primitive, RequiredProps, TupleKeys, WatchCallback, WatchEvent, Watchable, Writable };

package/apprt-core/clone.d.ts

@@ -94,4 +94,5 @@ type TransformFunc = (value: any, ctx: TransformContext) => any | symbol;
  */
 declare function transform<Input = any, Output = Input>(value: Input, valueTransformer?: TransformFunc): Output;
 
-export { type TransformContext, type TransformFunc, clone, clone as default, transform };
+export { clone, clone as default, transform };
+export type { TransformContext, TransformFunc };

package/apprt-core/comparators.d.ts

@@ -16,7 +16,6 @@ type Comparator<T> = (a: T, b: T) => number;
  * If such things are compared and they are not equal, then the first argument is always treated as smaller.
  * e.g. `DEFAULT_COMPARE({}, undefined) === DEFAULT_COMPARE(undefined, {}) === -1`
  *
- * @implements Comparator
  */
 declare const DEFAULT_COMPARE: (a: any, b: any) => number;
 /**
@@ -31,7 +30,6 @@ declare const TYPE_BASED_COMPARE: (a: any, b: any) => number;
  * Compares strings while treating uppercase and lowercase characters as equal.
  * This methods will throw an error if the objects are no strings.
  *
- * @implements Comparator
  */
 declare const IGNORE_CASE: (a: any, b: any) => number;
 /**
@@ -71,7 +69,6 @@ interface Comparable<T> {
 /**
  * Compares objects using the compareTo function provided in the first object.
  * If the 'compareTo' function is not available then it falls back to the DEFAULT_COMPARE.
- * @implements Comparator
  * @example _Usage with a class_
  * ```
  * import { BY_COMPARE_TO, DEFAULT_COMPARE } from "apprt-core/comparators"
@@ -199,4 +196,5 @@ keyof ObjectType | AllFieldSpecObjects<ObjectType, keyof ObjectType>;
  */
 declare function compareFields<ObjectType>(...fields: FieldSpec<ObjectType>[]): Comparator<ObjectType>;
 
-export { BY_COMPARE_TO, type Comparable, type Comparator, DEFAULT_COMPARE, type FieldSpecObject, IGNORE_CASE, TYPE_BASED_COMPARE, compareFields, createStringComparator, createStringWithNumberPartsComparator };
+export { BY_COMPARE_TO, DEFAULT_COMPARE, IGNORE_CASE, TYPE_BASED_COMPARE, compareFields, createStringComparator, createStringWithNumberPartsComparator };
+export type { Comparable, Comparator, FieldSpecObject };

package/apprt-core/config.d.ts

@@ -64,6 +64,10 @@ interface WellknownConfigKeys {
      * Defines that switching to HTTP POST is allowed during layer.js pre-fetching.
      */
     "app-launch-prefetch-with-post-enabled": boolean;
+    /**
+     * Instead of switching to post, the pre-fetching is using mulitple get requests if the url is to long.
+     */
+    "app-launch-prefetch-with-get-split": boolean;
     /**
      * Defines that the layer.js request is using gzip encoded parameters to keep the parameter size short.
      */
@@ -99,7 +103,7 @@ interface WellknownConfigKeys {
      */
     "esri-identity-app-token-enabled": boolean;
     /**
-     * Enables the persistence of the esri/identity/IdentityManager state in the local storage.
+     * Enables the persistence of the @arcgis/core/identity/IdentityManager state in the local storage.
      */
     "esri-identity-state-persist": boolean;
     /**
@@ -113,7 +117,7 @@ interface WellknownConfigKeys {
      */
     "esri-identity-state-name-prefix": string;
     /**
-     * Allows the esri/IdentityManager to send credentials via http.
+     * Allows the @arcgis/core/IdentityManager to send credentials via http.
      * Note this is only intended for development purpose
      * and should never be enabled during production.
      */
@@ -174,11 +178,7 @@ interface WellknownConfigKeys {
      */
     "request-trusted-servers": string[];
     /**
-     * Flag for apprt-request to return dojo/Deferred instead of Promises.
-     */
-    "request-return-dojo-deferred": boolean;
-    /**
-     * Plain esri key, provides a way to configure the properties in esri/config.
+     * Plain esri key, provides a way to configure the properties in @arcgis/core/config.
      * Used by apprt-esri-init.
      */
     "esri-conf": {
@@ -378,4 +378,5 @@ declare function unregisterEnvValue(key: EnvKey): boolean;
  */
 declare function setEnvValueInterceptor(interceptor?: Interceptor): void;
 
-export { type ConfigKey, type EnvKey, type Interceptor, LazyValues, type RegisterOptions, type SupportedValueTypes, type ValueOrValueProvider, type ValueProvider, type WellknownConfigKeys, type WellknownEnvKeys, configValue, envValue, registerConfigValue, registerEnvValue, setConfigValueInterceptor, setEnvValueInterceptor, unregisterConfigValue, unregisterEnvValue };
+export { LazyValues, configValue, envValue, registerConfigValue, registerEnvValue, setConfigValueInterceptor, setEnvValueInterceptor, unregisterConfigValue, unregisterEnvValue };
+export type { ConfigKey, EnvKey, Interceptor, RegisterOptions, SupportedValueTypes, ValueOrValueProvider, ValueProvider, WellknownConfigKeys, WellknownEnvKeys };

package/apprt-core/freeze.d.ts

@@ -22,4 +22,5 @@ type DeepFrozen<T> = T extends Record<string | symbol, any> | any[] ? {
  */
 declare function freeze<T>(obj: T): DeepFrozen<T>;
 
-export { type DeepFrozen, freeze as default, freeze };
+export { freeze as default, freeze };
+export type { DeepFrozen };

package/apprt-core/join.d.ts

@@ -42,4 +42,5 @@ interface JoinError {
  */
 declare function join<T>(promises: (T | PromiseLike<T>)[]): CancelablePromise<T[]>;
 
-export { type JoinError, join as default, join };
+export { join as default, join };
+export type { JoinError };

package/apprt-core/load-css.d.ts

@@ -43,4 +43,5 @@ interface LoadCssResult {
 declare function loadCss(hrefs: string[], timeout?: number): CancelablePromise<LoadCssResult[]>;
 declare function loadCss(href: string, timeout?: number): CancelablePromise<LoadCssResult>;
 
-export { type LoadCssResult, loadCss as default, loadCss };
+export { loadCss as default, loadCss };
+export type { LoadCssResult };

package/apprt-core/load-js.d.ts

@@ -20,7 +20,7 @@ interface LoadJsOptions {
  * ```ts
  * import loadJS from "apprt-core/load-js";
  *
- * loadJS("esri/Map").then(function(Map){
+ * loadJS("@arcgis/core/Map").then(function(Map){
  *     return new Map();
  * });
  * ```
@@ -40,4 +40,5 @@ interface LoadJsOptions {
  */
 declare function loadJS(clazzes?: string | Array<string>, options?: LoadJsOptions): ExtendedPromise<any>;
 
-export { type LoadJsOptions, loadJS as default, loadJS };
+export { loadJS as default, loadJS };
+export type { LoadJsOptions };

package/apprt-core/package.json

@@ -1,5 +1,5 @@
 {
     "name": "apprt-core",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/apprt-core/parallel.d.ts

@@ -20,4 +20,5 @@ interface RunParallelOptions {
  */
 declare function runParallel<T>(tasks: Task<T>[], options?: RunParallelOptions): Promise<T>[];
 
-export { type RunParallelOptions, type Task, runParallel };
+export { runParallel };
+export type { RunParallelOptions, Task };

package/apprt-core/promise-utils.d.ts

@@ -76,4 +76,5 @@ declare class LazyValue<T> {
     get value(): T | undefined;
 }
 
-export { LazyValue, type ManualPromise, createManualPromise };
+export { LazyValue, createManualPromise };
+export type { ManualPromise };

package/apprt-core/string-replace.d.ts

@@ -112,4 +112,5 @@ declare function customReplacer(options?: ReplaceOptions): StringReplacer;
  */
 declare const replace: StringReplacer;
 
-export { type ReplaceOptions, type StringReplacer, type ValueLookup, type ValueResolver, customReplacer, replace as default, replace };
+export { customReplacer, replace as default, replace };
+export type { ReplaceOptions, StringReplacer, ValueLookup, ValueResolver };

package/apprt-dom/index.d.ts

@@ -165,4 +165,5 @@ declare function getMarginSize(node: HTMLElement): MarginSize;
  */
 declare function setMarginBox(node: HTMLElement, marginBox: Partial<MarginBox>): void;
 
-export { type CreateOptions, type CssClasses, type ElementTag, type MarginBox, type MarginSize, type NodePosition, type NodeProperties, addClass, applyClass, createElement, destroyElement, getMarginBox, getMarginSize, insertElement, removeClass, setMarginBox, toggleClass };
+export { addClass, applyClass, createElement, destroyElement, getMarginBox, getMarginSize, insertElement, removeClass, setMarginBox, toggleClass };
+export type { CreateOptions, CssClasses, ElementTag, MarginBox, MarginSize, NodePosition, NodeProperties };

package/apprt-dom/package.json

@@ -1,5 +1,5 @@
 {
     "name": "apprt-dom",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": "./index.d.ts"
 }

package/apprt-fetch/index.d.ts

@@ -365,7 +365,7 @@ interface Config {
 /** Used to control the proxy mode for requests. */
 type ProxyMode = "force-on" | "force-off" | "default";
 /**
- * Request options supported by apprt-request.
+ * Request options supported by apprt-fetch.
  * This is an extension of the Browser's native fetch options.
  *
  * See also the init parameter of [apprt-fetch](https://developer.mozilla.org/en-US/docs/Web/API/fetch)
@@ -536,4 +536,5 @@ declare function createCustomFetch(options: {
  */
 declare function getGlobalImpl(): CustomFetch;
 
-export { type AfterInterceptorData, type ApprtRequestInit, type ApprtRequestTarget, type BasicFetchFunction, type BeforeInterceptorData, type Config, ContentType, type CustomFetch, type Handle, type Interceptor, type InterceptorOptions, type ProxyMode, type ProxyRule, type ProxyUrlOptions, type TrustedServer, apprtFetch, apprtFetchJson, createCustomFetch, apprtFetch as fetch, getConfig, getGlobalImpl, getProxiedUrl };
+export { ContentType, apprtFetch, apprtFetchJson, createCustomFetch, apprtFetch as fetch, getConfig, getGlobalImpl, getProxiedUrl };
+export type { AfterInterceptorData, ApprtRequestInit, ApprtRequestTarget, BasicFetchFunction, BeforeInterceptorData, Config, CustomFetch, Handle, Interceptor, InterceptorOptions, ProxyMode, ProxyRule, ProxyUrlOptions, TrustedServer };