@conterra/ct-mapapps-typings 4.19.2-next.20250325045859 → 4.19.2-next.20250402042452

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/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 {

package/apprt/launch/BundleController.d.ts

@@ -1,5 +1,5 @@
 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 {
@@ -77,4 +77,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 };
+export type { BundleControllerConstructorOptions };

package/apprt/launch/Launcher.d.ts

@@ -1,4 +1,4 @@
-import { LocationDefinition, Launcher, LauncherOptions, Framework } from '../api/index.js';
+import { Launcher, LocationDefinition, LauncherOptions, Framework } from '../api/index.js';
 import { BundleLocator, ConfigLocator } from '../api/internal.js';
 import 'apprt-core/Types';
 
@@ -69,4 +69,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/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-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

@@ -281,4 +281,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, 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/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

@@ -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

@@ -199,4 +199,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

@@ -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

@@ -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/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-fetch/index.d.ts

@@ -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 };

package/apprt-vuetify/RegisterVuetify.d.ts

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

package/ct/tools/Tool.d.ts

@@ -1,3 +1,302 @@
-declare const _default: any;
+/*
+ * Copyright (C) con terra GmbH
+ */
 
-export { _default as default };
+/**
+ * Utility type to create more specific parameter typings for {@link Stateful.watch}'s callback.
+ *
+ * This allows us to make the types of the callback's value parameters
+ * dependent on the callback's name parameter. This way, handler code like
+ * the following is well-typed:
+ * ```ts
+ * let stateful: Stateful<{id: string, priority: number}>;
+ * stateful.watch('*', (name, oldValue, newValue) => {
+ *   if (name === 'id') {
+ *     // TypeScript can now infer that newValue is a string
+ *     console.log(newValue.substring(0, 4));
+ *   }
+ *   if (name === 'priority') {
+ *     // TypeScript can now infer that oldValue and newValue are numbers
+ *     console.log(newValue - oldValue);
+ *   }
+ * });
+ * ```
+ *
+ * This uses TypeScript's distributive behavior in conditional types to turn
+ * a union of properties into a union of tuples.
+ *
+ * @see https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+ */
+type WatchCallbackParams<T, P extends keyof T> = P extends unknown
+    ? [name: P, oldValue: T[P], newValue: T[P]]
+    : never
+    ;
+
+type Stateful<T> = T & {
+    watch: <Prop extends keyof T | '*'>(
+        property: Prop,
+        handler: (...args: WatchCallbackParams<T, Prop extends '*' ? keyof T : Prop>) => void
+    ) => void
+
+    set: <Prop extends keyof T>(
+        property: Prop,
+        value: T[Prop]
+    ) => void
+
+    get: <Prop extends keyof T>(
+        property: Prop
+    ) => T[Prop]
+};
+
+/** Placeholder type for parameters to all the Evented functions. */
+type Event = unknown;
+
+/** Utility type for all the handler functions in Tool. */
+type HandlerFn<This, Event, Result> = ((this: This, event: Event) => Result) | undefined;
+
+/** A partial copy of the declaration in ct/tools/Tool adapted for TypeScript. The types are mostly educated guesses. */
+interface ToolProperties {
+    /**
+     * Given tool id.
+     */
+    id: string
+    /**
+     * The title of the tool.
+     */
+    title: string | undefined
+    /**
+     * A description of the tool.
+     */
+    description: string | undefined
+    /**
+     * A tool tip.
+     */
+    tooltip: string | undefined
+    /**
+     * The tooltip positions.
+     * e.g. ["above","below","after","before"]
+     */
+    tooltipPositions: ("above" | "below" | "after" | "before")[] | undefined
+    /**
+     * Priority is used to ensure an ordering of tools.
+     * Tools with high priority are first, equal priority means sort by id.
+     */
+    priority: number
+    /**
+     * A tool group this information is also added as css class to the root node of the created button or menu.
+     */
+    toolGroup: string
+    /**
+     * A tool class appended to the root node of the created button or menu.
+     * Note that ctTool_${id} is always added
+     */
+    toolClass: string
+    /**
+     * A tool icon class appended to the icon node of the created button or menu.
+     * Note that ctToolIcon_${id} is always added
+     */
+    iconClass: string
+    /**
+     * The visible state of the tool.
+     * On change the onShow/onHide events are fired.
+     */
+    visibility: boolean
+    /**
+     * The enabled state of the tool.
+     * On change the onDisabled, onEnabled events are fired.
+     */
+    enabled: boolean
+    /**
+     * The active state of the tool, this is only of interest if the tool is togglable.
+     * On change the onActivate, onDeactivate events are fired.
+     */
+    active: boolean
+    /**
+     * The togglable state of the tool, this marks that the tool can be toggled.
+     * It should be set in the constructor and the state value should never dynamically change.
+     */
+    togglable: boolean
+    /**
+     * The processing state of the tool, this marks that the tool is currently processing something.
+     * The state is toggled by the fireProcess* methods and independent from any other state of the tool.
+     */
+    processing: boolean
+    /**
+     * The self reference. Please see the ToolReference class to note that this property allows
+     * to handle a tool like a tool reference, which makes code expecting references to be used with tools directly.
+     */
+    tool: Tool
+    /**
+     * Flag auto disables the tool if it becomes hidden.
+     * default: true.
+     */
+    disableOnHide: boolean
+    /**
+     * Flag auto enables the tool if it becomes visible.
+     * default: true.
+     */
+    enableOnShow: boolean
+    /**
+     * Flag auto deactivates the tool if it is disabled.
+     * default: true.
+     */
+    deactivateOnDisable: boolean
+    /**
+     * Flag auto activates the tool if it is enabled.
+     * default: false.
+     */
+    activateOnEnable: boolean
+    /**
+     * Flag auto enables the tool if set("active",true) is called.
+     */
+    enableOnActivate: boolean
+    /**
+     * The scope of the default handler functions.
+     */
+    handlerScope: object | null
+    /**
+     * The handler function called if the tool is clicked.
+     */
+    clickHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool is double clicked.
+     */
+    dblClickHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called before the onActivate event is fired.
+     */
+    beforeActivateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool is activated.
+     */
+    activateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called before the onDeactivate event is fired.
+     */
+    beforeDeactivateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool is deactivated.
+     */
+    deactivateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool becomes enabled.
+     */
+    enabledHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool becomes disabled.
+     */
+    disabledHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool becomes visible.
+     */
+    showHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool becomes hidden.
+     */
+    hideHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool starts a processing task.
+     */
+    processStartHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * The handler function called if the tool ends a processing task.
+     */
+    processEndHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    /**
+     * Rules flag read by the toolrules bundle (optional).
+     */
+    rules: object | null
+    /**
+     * The handler function called to check a condition before activating a togglable tool.
+     * The function has to return true if condition is fulfilled and false if not.
+     */
+    activationConditionHandler: HandlerFn<ToolProperties["activationConditionHandlerScope"] | Tool, Event, boolean>
+    /**
+     * The scope of the activation condition handler function.
+     */
+    activationConditionHandlerScope: object | null
+    /**
+     * If true real click,check/uncheck,dblclick events are delegated async into the tool model,
+     * so that the browser event flow is not broken.
+     */
+    async: boolean
+    /**
+     * Simulates a click on the tool.
+     * Please note that this does not change the active state.
+     * A client have to call set("active",true|false) to change the state.
+     */
+    click(evt: Event): void;
+    /**
+     * Simulates a dbl click on the tool.
+     */
+    dblClick(evt: Event): void;
+    /**
+     * Sends a info message to the tool. It simple fires the onInfoMessage() event.
+     * Such a message is normally produced in the backend, to indicate a "please click me" state on the tool.
+     */
+    infoMsg(msgObj: { message: string }): void;
+    /**
+     * The onClick event
+     */
+    onClick(event: Event): void;
+    /**
+     * The onDoubleClick event
+     **/
+    onDblClick(event: Event): void;
+    /**
+     * The onInfoMessage event, transports a message from the backend to the tool widget.
+     **/
+    onInfoMessage(event: Event): void;
+    /**
+     * The onBeforeActivate event, it is called short before onActivate.
+     **/
+    onBeforeActivate(event: Event): void;
+    /**
+     * The onActivate event
+     **/
+    onActivate(event: Event): void;
+    /**
+     * The onDeactivate event
+     **/
+    onDeactivate(event: Event): void;
+    /**
+     * The onBeforeDeactivate event, it is called short before onDeactivate.
+     **/
+    onBeforeDeactivate(event: Event): void;
+    /**
+     * The onEnabled event, if the tool becomes enabled (available for pressing)
+     **/
+    onEnabled(event: Event): void;
+    /**
+     * The onDisabled event, if the tool becomes disabled (not available for pressing)
+     **/
+    onDisabled(event: Event): void;
+    /**
+     * The onShow event, if the tool becomes visible (allowed to show on screen)
+     **/
+    onShow(event: Event): void;
+    /**
+     * The onHide event, if the tool becomes hidden (not allowed to show on screen)
+     **/
+    onHide(event: Event): void;
+    /**
+     * `onProcessStart` is called when an external process is started
+     */
+    onProcessStart(event: Event): void;
+    /**
+     * `onProcessEnd` is called when an external process is stopped
+     */
+    onProcessEnd(event: Event): void;
+}
+
+interface ToolConstructor {
+    new(props?: Partial<ToolProperties>): Tool;
+}
+
+type Tool = Stateful<ToolProperties>;
+
+// Declaring a type and a variable of the same name is a technique used by
+// TypeScript's type declarations for standard library types such as Date.
+declare const Tool: ToolConstructor;
+
+export { Tool as default };

package/esri-widgets/EsriDijit.d.ts

@@ -8,4 +8,5 @@ declare function createDijit<T extends EsriWidget>(esriWidget: T, extraOptions?:
     class?: string;
 }): EsriDijit<T>;
 
-export { type EsriDijit, createDijit, createDijit as default };
+export { createDijit, createDijit as default };
+export type { EsriDijit };

package/map-widget/LayerObserver.d.ts

@@ -39,4 +39,5 @@ interface LayerObserver {
 }
 declare function createLayerObserver({ map, layers, filter, notify, onlyWatching }?: Partial<LayerObserverOptions>): LayerObserver;
 
-export { type Context, type LayerObserver, type LayerObserverOptions, type NotifyReason, createLayerObserver, createLayerObserver as default };
+export { createLayerObserver, createLayerObserver as default };
+export type { Context, LayerObserver, LayerObserverOptions, NotifyReason };

package/map-widget/LayerTraverser.d.ts

@@ -28,4 +28,5 @@ declare enum VisitCodes {
 }
 declare function createLayerTraverser(globalOpts?: Partial<LayerTraverserOptions>): LayerTraverser;
 
-export { type LayerNode, type LayerTraverser, type LayerTraverserOptions, VisitCodes, createLayerTraverser, createLayerTraverser as default };
+export { VisitCodes, createLayerTraverser, createLayerTraverser as default };
+export type { LayerNode, LayerTraverser, LayerTraverserOptions };

package/map-widget/ViewReadyWatcher.d.ts

@@ -24,4 +24,5 @@ interface ViewReadyWatcher {
 }
 declare function createViewReadyWatcher(model: MapWidgetModel): ViewReadyWatcher;
 
-export { type ViewReadyCallback, type ViewReadyWatcher, createViewReadyWatcher, createViewReadyWatcher as default };
+export { createViewReadyWatcher, createViewReadyWatcher as default };
+export type { ViewReadyCallback, ViewReadyWatcher };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@conterra/ct-mapapps-typings",
-"version": "4.19.2-next.20250325045859",
+"version": "4.19.2-next.20250402042452",
     "description": "TypeDefinitions for ct-mapapps",
     "author": "conterra",
     "license": "Apache-2.0"

package/popups/BaseAction.d.ts

@@ -59,4 +59,5 @@ type BaseActionConstructor<Type extends EsriActionType> = new (properties?: Esri
  */
 declare function BaseAction<Type extends EsriActionType>(type: Type): BaseActionConstructor<Type>;
 
-export { type BaseActionConstructor, type EsriAction, type EsriActionType, type ExtendedEsriAction, BaseAction as default };
+export { BaseAction as default };
+export type { BaseActionConstructor, EsriAction, EsriActionType, ExtendedEsriAction };

package/popups/ContentUpdateProxy.d.ts

@@ -92,4 +92,5 @@ interface WidgetProxy {
  */
 declare function ContentUpdateProxy(graphic: Graphic, dijit: any, triggerUpdate: (graphic: Graphic) => void): WidgetProxy;
 
-export { type WidgetProxy, ContentUpdateProxy as default };
+export { ContentUpdateProxy as default };
+export type { WidgetProxy };

package/result-api/api/actions.d.ts

@@ -1,4 +1,4 @@
-import { DataTable, TableItem, DataTableCollection } from '../__internal__/Bnw4PH_u.js';
+import { DataTableCollection, DataTable, TableItem } from '../__internal__/Bnw4PH_u.js';
 import { EventSource } from 'apprt-core/Events';
 import 'apprt-core/Types';
 import 'esri/geometry';

package/selection-services/DrawingSpatialInputAction.d.ts

@@ -26,4 +26,5 @@ declare class DrawingSpatialInputAction extends SpatialInputActionImpl {
     _intercept(geometry: Geometry, options: Record<string, any>): Geometry;
 }
 
-export { type DrawingSpatialInputActionOptions, DrawingSpatialInputAction as default };
+export { DrawingSpatialInputAction as default };
+export type { DrawingSpatialInputActionOptions };

package/selection-services/SearchSource.d.ts

@@ -42,4 +42,5 @@ interface SearchSourceConstructor {
 }
 declare const _default: SearchSourceConstructor;
 
-export { type SearchSourceConstructor, type SearchSourceConstructorOptions, _default as default };
+export { _default as default };
+export type { SearchSourceConstructor, SearchSourceConstructorOptions };

package/selection-services/SpatialInputAction.d.ts

@@ -31,4 +31,5 @@ declare class SpatialInputActionImpl implements SpatialInputAction {
     trigger(options: Record<string, any>): CancelablePromise<Geometry>;
 }
 
-export { type CommonSpatialInputActionOptions, SpatialInputActionImpl as default };
+export { SpatialInputActionImpl as default };
+export type { CommonSpatialInputActionOptions };

package/store-api/ComplexQuery.d.ts

@@ -292,4 +292,5 @@ declare class ComplexQuery {
  */
 declare function encodePostOrder<T>(encoder: Encoder<T>, walkerOrAst: Walker | AST): any;
 
-export { type AST, type ASTNode, type ChildVisitCallback, ComplexQuery, type ComplexQueryOptions, type Encoder, type OperatorChain, type OperatorImpl, type VisitCallback, type Walker, ComplexQuery as default, encodePostOrder, walkerForASTNode };
+export { ComplexQuery, ComplexQuery as default, encodePostOrder, walkerForASTNode };
+export type { AST, ASTNode, ChildVisitCallback, ComplexQueryOptions, Encoder, OperatorChain, OperatorImpl, VisitCallback, Walker };

package/store-api/InMemoryStore.d.ts

@@ -77,4 +77,5 @@ declare class AsyncWritableInMemoryStore<ItemType extends Record<string, any>, I
     remove(id: IDType): Promise<void>;
 }
 
-export { AsyncInMemoryStore, AsyncWritableInMemoryStore, type ConstructorOptions, SyncInMemoryStore, SyncWritableInMemoryStore };
+export { AsyncInMemoryStore, AsyncWritableInMemoryStore, SyncInMemoryStore, SyncWritableInMemoryStore };
+export type { ConstructorOptions };

package/store-api/QueryExecution.d.ts

@@ -93,4 +93,5 @@ type QueryExecutionConstructor<T> = new (options?: QueryExecutionConstructorOpti
 /** Creates a QueryExecution */
 declare const _default: QueryExecutionConstructor<unknown>;
 
-export { type DataSource, type QueryExecution, type QueryExecutionConstructor, type QueryResult, type ResultItems, type Watchable, _default as default };
+export { _default as default };
+export type { DataSource, QueryExecution, QueryExecutionConstructor, QueryResult, ResultItems, Watchable };

package/store-api/QueryExecutions.d.ts

@@ -1,4 +1,4 @@
-import { QueryExecution, Watchable } from './QueryExecution.js';
+import { Watchable, QueryExecution } from './QueryExecution.js';
 import 'apprt-core/Mutable';
 
 type QueryExecutionsConstructorOptions = Partial<Pick<QueryExecutions, "executions">>;
@@ -47,4 +47,5 @@ type QueryExecutionsConstructor = new (options?: QueryExecutionsConstructorOptio
  */
 declare const _default: QueryExecutionsConstructor;
 
-export { type QueryExecutionStrategy, type QueryExecutions, type QueryExecutionsConstructor, _default as default };
+export { _default as default };
+export type { QueryExecutionStrategy, QueryExecutions, QueryExecutionsConstructor };

package/store-api/SpatialQuery.d.ts

@@ -31,4 +31,5 @@ interface SpatialQueryExtension {
 /** reexports ComplexQuery with spatial operators */
 declare const SpatialQuery: SpatialQueryType;
 
-export { SpatialQuery, type SpatialQueryExtension, type SpatialQueryType, SpatialQuery as default };
+export { SpatialQuery, SpatialQuery as default };
+export type { SpatialQueryExtension, SpatialQueryType };

package/store-api/rest/BaseRestStore.d.ts

@@ -180,4 +180,5 @@ declare class BaseRestStore<ItemType extends IndexableThing, IDType extends stri
     private _fetchMetadata;
 }
 
-export { BaseRestStore, type InternalRequestOptions, type MethodParameters, type RequestOptions };
+export { BaseRestStore };
+export type { InternalRequestOptions, MethodParameters, RequestOptions };

package/store-api/rest/ComplexQueryToSolrQL.d.ts

@@ -67,4 +67,5 @@ declare const toSolrQL: (query?: ComplexQueryExpression | undefined, options?: C
 declare const astToSolrQL: (astOrWalker: Walker | AST) => string;
 declare const _operatorMapping: Record<string, Transformer>;
 
-export { type ComplexQueryToSolrQLOptions, type CustomTransformer, type Transformer, _operatorMapping, astToSolrQL, overload, toSolrQL };
+export { _operatorMapping, astToSolrQL, overload, toSolrQL };
+export type { ComplexQueryToSolrQLOptions, CustomTransformer, Transformer };

package/store-api/utils.d.ts

@@ -1,7 +1,7 @@
 import CancelablePromise from 'apprt-core/CancelablePromise';
 import CPromise from 'apprt-core/Promise';
 import { ComplexQueryOptions } from './ComplexQuery.js';
-import { IndexableThing, ResultItems, SortOptions, PaginationOptions, AsyncQueryResult, Metadata } from './api/Store.js';
+import { ResultItems, AsyncQueryResult, IndexableThing, SortOptions, PaginationOptions, Metadata } from './api/Store.js';
 import { ComplexQueryExpression } from './api/ComplexQueryLang.js';
 import 'apprt-core/Events';
 import 'esri/geometry/Geometry';

package/system/api/internal.d.ts

@@ -1,5 +1,5 @@
 import CancelablePromise from 'apprt-core/CancelablePromise';
-import { ComponentContext, Bundle, ComponentProperties, BundleContext, ServiceReference, ServiceInstance, BundleId, ServiceEvent, AnyPropertyValue, ConfigurationStore, ConfigAdminService, ConfigurationStoreEntry, Configuration, AppConfigJson } from 'apprt/api';
+import { ServiceInstance, ComponentContext, ComponentProperties, Bundle, BundleContext, ServiceReference, BundleId, ServiceEvent, AnyPropertyValue, ConfigurationStore, ConfigAdminService, ConfigurationStoreEntry, Configuration, AppConfigJson } from 'apprt/api';
 
 interface InternalComponentContext<ExpectedServiceType extends ComponentServiceInstance> extends ComponentContext<ExpectedServiceType> {
     dispose(): void;

package/system/user/Authentication.d.ts

@@ -1,4 +1,4 @@
-import { UserAdminService, Authentication, User } from 'apprt/api';
+import { Authentication, UserAdminService, User } from 'apprt/api';
 
 interface AuthenticationOptions {
     name?: string;
@@ -21,4 +21,5 @@ declare class AuthenticationImpl implements Authentication {
     logout(): boolean | Promise<boolean>;
 }
 
-export { type AuthenticationOptions, AuthenticationImpl as default };
+export { AuthenticationImpl as default };
+export type { AuthenticationOptions };

package/system/user/Authorization.d.ts

@@ -15,4 +15,5 @@ declare class AuthorizationImpl implements Authorization {
     getRoles(): string[];
 }
 
-export { type AuthorizationOptions, AuthorizationImpl as default };
+export { AuthorizationImpl as default };
+export type { AuthorizationOptions };

package/system/user/User.d.ts

@@ -12,4 +12,5 @@ declare class UserImpl implements User {
     get(key: string): any;
 }
 
-export { type UserOptions, UserImpl as default };
+export { UserImpl as default };
+export type { UserOptions };

package/test-utils/waitFor.d.ts

@@ -49,4 +49,5 @@ declare function waitUntil<T>(resolver: () => Promise<T> | T, options?: WaitOpti
  */
 declare function sleep(timeout?: number): Promise<void>;
 
-export { type WaitOptions, sleep, waitFor, waitUntil };
+export { sleep, waitFor, waitUntil };
+export type { WaitOptions };