@conterra/ct-mapapps-typings 4.19.3-next.20250627112807 → 4.19.3

package/resultcenter/SearchStoreHandler.d.ts

@@ -0,0 +1,8 @@
+declare function _default(): {
+    showData(event: any): void;
+    clearData(event: any): void;
+    handleDataSourceUpdate(event: any): void;
+    deactivate(): void;
+};
+
+export { _default as default };

package/resultcenter/SelectAllResultsCommand.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Base class for select all command of result center.
+ */
+declare class SelectAllResultsCommand {
+    deactivate(): void;
+    _selected: boolean | null | undefined;
+    selectAll(): void;
+    handleDataSourceChanged(): void;
+}
+
+export { SelectAllResultsCommand as default };

package/resultcenter/StoreEventReceiver.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+
+export { _default as default };

package/resultcenter/StoreRegistration.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+
+export { _default as default };

package/resultcenter/TriggerShowResultCenter.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+
+export { _default as default };

package/resultcenter/VisualizationLayerResolver.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Helper of FeatureMapVisualizer to ensure that graphics rendered to special layer.
+ */
+declare class VisualizationLayerResolver {
+    constructor(layerId: any, layerTitle: any);
+    layerId: any;
+    layerTitle: any;
+    resolve(mapWidgetModel: any): any;
+    remove(): void;
+    #private;
+}
+
+export { VisualizationLayerResolver as default };

package/resultcenter/package.json

@@ -0,0 +1,5 @@
+{
+    "name": "resultcenter",
+    "version": "4.19.3",
+    "types": ""
+}

package/search-api/api.d.ts

@@ -50,15 +50,6 @@ interface SearchOptions {
      * The default value is `15`.
      */
     count?: number;
-    /**
-     * Whether to request the number of total results from the queries stores.
-     *
-     * This is true by default for backwards compatibility reasons.
-     * Set this to `false` to skip requesting the total result count.
-     *
-     * See also {@link ResultSet.total}.
-     */
-    queryTotal?: boolean;
     /**
      * An optional array of map action IDs.
      * The associated map actions are triggered when an item is selected (see {@link ResultItem.select}).
@@ -122,13 +113,8 @@ interface ResultGroup {
 interface ResultSet {
     /** Result items, up to the requested amount. */
     readonly items: ResultItem[];
-    /**
-     * Total number of available results.
-     *
-     * This is present if the `queryTotal` option is set to `true` (the default).
-     * This is always undefined if `queryTotal` is set to `false`.
-     */
-    readonly total: number | undefined;
+    /** Total number of available results */
+    readonly total: number;
     /**
      * Selects multiple items at once.
      * The items must belong to this result set (from `this.items`).

package/search-api/package.json

@@ -1,5 +1,5 @@
 {
     "name": "search-api",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/search-ui/package.json

@@ -1,5 +1,5 @@
 {
     "name": "search-ui",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/selection-resultcenter/CachingStore.d.ts

@@ -0,0 +1,229 @@
+import * as store_api_api from 'store-api/api';
+
+/**
+ * The methods of this interface are available when a Promise
+ * has been augmented using the `trackState` function.
+ */
+interface StateQueryable {
+    /** Returns true if the promise is settled, i.e. if it is no longer pending. */
+    isSettled(): boolean;
+    /** Returns true if the promise is fulfilled, i.e. if it has a success value. */
+    isFulfilled(): boolean;
+    /** Returns true if the promise is rejected, i.e. if it contains an error. */
+    isRejected(): boolean;
+    /** Returns true if the promise was cancelled before it was able to complete. */
+    isCancelled(): boolean;
+}
+type State = "pending" | "fulfilled" | "rejected" | "cancelled";
+declare const PROMISE: unique symbol;
+declare const STATE: unique symbol;
+declare const PRIVATE_CONSTRUCTOR_TAG: unique symbol;
+/**
+ * Wrapper of global.Promise class.
+ * Read more about [Promises](./PROMISES.md).
+ *
+ * @see https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Promise
+ */
+declare class ExtendedPromise<T> implements Promise<T> {
+    private [PROMISE];
+    private [STATE]?;
+    /**
+     * Creates Promise instances.
+     * @param executor defined as (resolve,reject)=> \{\}
+     * @example
+     * ```ts
+     * new Promise((resolve, reject)=>{
+     *      ...
+     * });
+     * ```
+     */
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void);
+    /**
+     * Internal constructor. Do not call.
+     */
+    constructor(promise: PromiseLike<T> | LegacyDojoDeferred, state: State | undefined, tag: typeof PRIVATE_CONSTRUCTOR_TAG);
+    /** Creates a new resolved promise */
+    static resolve(): ExtendedPromise<void>;
+    /**
+     * Creates a new resolved promise with the given value
+     * @param value result object.
+     * @returns a promise in fulfilled state.
+     */
+    static resolve<T>(value: T): ExtendedPromise<T>;
+    /**
+     * @param reason The reason the promise was rejected.
+     * @returns a promise in rejected state.
+     */
+    static reject<T = never>(reason?: any): ExtendedPromise<T>;
+    /**
+     * Creates promise which fulfills if all other promises are fulfilled.
+     * Or rejects if one of the promises rejects.
+     *
+     * @param iterable Iterable of Promise instances
+     */
+    static all<T extends readonly unknown[] | []>(iterable: T): ExtendedPromise<{
+        -readonly [P in keyof T]: Awaited<T[P]>;
+    }>;
+    /**
+     * Creates promise which fulfills if one of the other promises fulfills.
+     * Or rejects if one of the promises rejects.
+     *
+     * @param iterable Iterable of Promise instances
+     */
+    static race<T>(iterable: Iterable<T>): ExtendedPromise<T extends PromiseLike<infer U> ? U : T>;
+    /**
+     * Creates promise which fulfills if one of the other promises fulfills.
+     * Or rejects if one of the promises rejects.
+     *
+     * @param iterable Iterable of Promise instances
+     */
+    static race<T>(iterable: Iterable<T | PromiseLike<T>>): ExtendedPromise<T>;
+    /**
+     * Creates a promise that resolves after all of the given promises have either fulfilled or rejected,
+     * with an array of objects that each describes the outcome of each promise.
+     *
+     * @param iterable Iterable of Promise instances
+     */
+    static allSettled<T>(iterable: Iterable<T | PromiseLike<T>>): ExtendedPromise<PromiseSettledResult<Awaited<T>>[]>;
+    /**
+     * Promise.any() takes an iterable of Promise objects and, as soon as one of the promises in the iterable fulfills,
+     * returns a single promise that resolves with the value from that promise.
+     * If no promises in the iterable fulfill (if all of the given promises are rejected),
+     * then the returned promise is rejected with an AggregateError,
+     * Essentially, this method is the opposite of Promise.all().
+     *
+     * @param iterable Iterable of Promise instances
+     */
+    static any<T>(iterable: (T | PromiseLike<T>)[] | Iterable<T | PromiseLike<T>>): ExtendedPromise<T>;
+    /**
+     * Produces an object with a promise along with its resolution and rejection functions.
+     * Allows to resolve/reject the promise manually after creating it.
+     *
+     * @example
+     * ```ts
+     * const { promise, resolve, reject } = Promise.withResolvers();
+     * ```
+     * @returns {{ promise, resolve, reject }}
+     */
+    static withResolvers<T>(): {
+        resolve: (value: T | PromiseLike<T>) => void;
+        reject: (reason?: unknown) => void;
+        promise: ExtendedPromise<T>;
+    };
+    /**
+     * This method tests if a given object is a promise.
+     * The algorithm will return true for:
+     *  * apprt-core/Promise
+     *  * global Promise
+     *  * dojo/Deferred
+     *  * dojo/Deferred.promise
+     *
+     * Note: Because of support for dojo/Deferred any object with a
+     * 'then', 'isResolved' and 'isRejected' method is detected as a promise.
+     *
+     * @param candidate a potential promise.
+     * @returns true if candidate is a promise.
+     */
+    static isPromise(candidate: any): candidate is PromiseLike<unknown>;
+    /**
+     * Wraps e.g. dojo/Deferred or native Promise to this Promise class.
+     * @returns a promise
+     */
+    static wrap<T>(promise: PromiseLike<T> | LegacyDojoDeferred): ExtendedPromise<T>;
+    /**
+     * Augments the given Promise with new state lookup functions.
+     */
+    static trackState<T>(promise: PromiseLike<T> | LegacyDojoDeferred): ExtendedPromise<T> & StateQueryable;
+    /**
+     * Registers success and/or error handlers.
+     * @param success called when the promise resolves
+     * @param failure called when the promise rejects
+     */
+    then<TResult1 = T, TResult2 = never>(success?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, failure?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): ExtendedPromise<TResult1 | TResult2>;
+    /**
+     * Registers an error handler.
+     * @param failure called when the promise rejects
+     */
+    catch<TResult = never>(failure?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): ExtendedPromise<T | TResult>;
+    /**
+     * Registers an error handler. Which is not called if the error is a Cancel instance.
+     * @param failure called when the promise rejects
+     */
+    else<TResult = never>(failure?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): ExtendedPromise<T | TResult>;
+    /**
+     * Registers a handler, which is called in success or error state.
+     * But the handler is not able to change the result state!
+     * @param handler function invoked regardless of success or error
+     */
+    finally(handler?: (() => void) | undefined | null): ExtendedPromise<T>;
+    /**
+     * @returns this instance, augmented with augmented with:
+     *
+     * *    isFulfilled()
+     * *    isRejected()
+     * *    isCancelled()
+     * *    isSettled()
+     */
+    trackState(): ExtendedPromise<T> & StateQueryable;
+    get [Symbol.toStringTag](): string;
+}
+
+interface LegacyDojoDeferred {
+    promise: any;
+    isResolved(): boolean;
+    isRejected(): boolean;
+    isFulfilled(): boolean;
+    isCanceled(): boolean;
+    progress(update: any, strict?: boolean): any;
+    resolve(value?: any, strict?: boolean): any;
+    reject(error?: any, strict?: boolean): any;
+    then(callback?: any, errback?: any, progback?: any): any;
+    cancel(reason?: any, strict?: boolean): any;
+    toString(): string;
+}
+
+/**
+ * This class provides a caching store. All used field values will be cached in a memory store.
+ */
+declare class CachingStore {
+    /**
+     * Defines if geometry will be cached
+     */
+    constructor(args: any);
+    maxFeaturesLimit: number;
+    initialQuery: any;
+    querySequenz: any;
+    idProperty: any;
+    _cache: any[];
+    _geometryCache: any;
+    idList: any[];
+    deactivate(): void;
+    getInitialQuery(): any;
+    _addItemToCache(item: any, offset: any): void;
+    _updateGeometryCache(item: any, offset: any): void;
+    getMetadata(object: any): any;
+    getIdentity(object: any): any;
+    _getAllMasterStoreFields(): ExtendedPromise<{}>;
+    _getItems(itemIds: any, opts: any): Promise<any[]>;
+    _buildQuery(itemIds: any): {};
+    _isGeometryRequired(options: any, defaultRequired: any): Any;
+    _getGeometryFromCache(id: any, offset: any): any;
+    _isSpatialQuery(query: any): boolean;
+    _getItemsFromCache(query: any, options?: {}): store_api_api.ResultItems<Readonly<Record<string, any>>>;
+    _getGeometryForItems(items: any, options: any): ExtendedPromise<any>;
+    _getItemsForQuery(query: any, options: any): ExtendedPromise<any[]>;
+    query(query: any, options: any): store_api_api.ResultItems<{}>;
+    _synchronizedQueryOnCache(query: any, opts: any): any;
+    querySequence: any;
+    _queryOnCache(query: any, opts: any): ExtendedPromise<any>;
+    _geometryMissingInCachedItems(offset: any, query: any, opts: any): boolean;
+    _getOffset(options: any): Any;
+    _checkIfCacheIsPopulated(): boolean;
+    _populateCache(): any;
+    _fetchCache: any;
+    get(id: any, options: any): any;
+    remove(id: any): boolean;
+    invalidate(id: any): void;
+}
+
+export { CachingStore as default };

package/selection-resultcenter/MemoryStore.d.ts

@@ -0,0 +1,10 @@
+import { AsyncWritableInMemoryStore } from 'store-api/InMemoryStore';
+
+declare class MemoryStore extends AsyncWritableInMemoryStore<any, any> {
+    constructor(opts: any);
+    masterStore: any;
+    idList: any;
+    getMetadata(): Promise<any>;
+}
+
+export { MemoryStore };

package/selection-resultcenter/package.json

@@ -0,0 +1,5 @@
+{
+    "name": "selection-resultcenter",
+    "version": "4.19.3",
+    "types": ""
+}

package/selection-services/package.json

@@ -1,5 +1,5 @@
 {
     "name": "selection-services",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/store-api/package.json

@@ -1,5 +1,5 @@
 {
     "name": "store-api",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/system/package.json

@@ -1,5 +1,5 @@
 {
     "name": "system",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/templatelayout/package.json

@@ -1,5 +1,5 @@
 {
     "name": "templatelayout",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/test-utils/package.json

@@ -1,5 +1,5 @@
 {
     "name": "test-utils",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/theme-tester/package.json

@@ -1,5 +1,5 @@
 {
     "name": "theme-tester",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/toc/package.json

@@ -1,5 +1,5 @@
 {
     "name": "toc",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/toolrules/package.json

@@ -1,5 +1,5 @@
 {
     "name": "toolrules",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/vuetify-component-overview/package.json

@@ -1,5 +1,5 @@
 {
     "name": "vuetify-component-overview",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/windowmanager/package.json

@@ -1,5 +1,5 @@
 {
     "name": "windowmanager",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/wizard/package.json

@@ -1,5 +1,5 @@
 {
     "name": "wizard",
-    "version": "4.19.3-SNAPSHOT",
+    "version": "4.19.3",
     "types": ""
 }

package/coordinateconversion/api.d.ts

@@ -1,181 +0,0 @@
-import { SpatialReference, Point } from 'esri/geometry';
-
-/**
- * Parsing succeeded and returned a valid value.
- */
-interface ParseSuccess<T> {
-    kind: "success";
-    value: T;
-}
-/**
- * Parsing resulted in an error.
- */
-interface ParseError {
-    kind: "error";
-    /**
-     * Human readable error message.
-     * This message may be presented to the user.
-     */
-    message?: string;
-}
-/**
- * The result of parsing inputs.
- */
-type ParseResult<T> = ParseSuccess<T> | ParseError;
-/**
- * Implements a format for coordinate conversions.
- *
- * You can extend the builtin set of formats by providing a service with `"coordinateconversion.SegmentedFormat"`.
- */
-interface SegmentedFormat {
-    /**
-     * Unique id of this format.
-     */
-    readonly id: string;
-    /**
-     * Human readable label of this format.
-     */
-    readonly label: string;
-    /**
-     * Input segments required by the format, for example `x` and `y` coordinates.
-     * The coordinate conversion widget shows one input field for each segment.
-     */
-    readonly segments: CoordinateSegment[];
-    /**
-     * When specified, points will be projected to this spatial reference before being passed to {@link pointToSegments}.
-     *
-     * If this is not specified, you will receive the point in the current spatial reference of the view, and
-     * you will have to perform any necessary projections yourself.
-     */
-    readonly spatialReference?: SpatialReference;
-    /**
-     * Renders a point to _segment_ values.
-     * The returned record is indexed by segment ids and contains a string for each segment.
-     *
-     * The output of this function should be compatible with {@link segmentsToPoint}.
-     *
-     * Example:
-     *
-     * ```js
-     * const point = ...;
-     * const segments = format.pointToSegments(point);
-     * // segments == { x: "...", y: "..." }
-     * ```
-     */
-    pointToSegments(point: Point): Promise<Record<string, string>>;
-    /**
-     * Formats a set of _segment_ values to a human readable string.
-     * This combines the segment values to a final display string, including separating characters (like ',' or ' ')
-     * and units (like '°' and '"').
-     *
-     * The `segments` parameter can be assumed to contain valid strings: either
-     * - user input validated by {@link CoordinateSegment.validate} or
-     * - segment values generated by {@link pointToSegments}.
-     *
-     * The value returned here should be compatible with {@link stringToSegments}.
-     *
-     * Example:
-     *
-     * ```js
-     * const segments = { x: "1", y: "2" }
-     * const output = format.segmentsToString(segments);
-     * // output == "1°, 2°"
-     * ``
-     */
-    segmentsToString(segments: Record<string, string>): string;
-    /**
-     * Splits a human readable coordinates string (like returned by {@link segmentsToString}) into its input segment.
-     *
-     * For example:
-     *
-     * ```js
-     * const input = "123.4 567.8";
-     * const segments = format.stringToSegments(input).value; // assumes success
-     * // segments == { x: "123.4", y: "567.8" };
-     * ```
-     */
-    stringToSegments(input: string): ParseResult<Record<string, string>>;
-    /**
-     * Parses a set of (validated) segment values into a `Point`.
-     * This can be used, for example, to place a marker on the map.
-     *
-     * Example:
-     *
-     * ```js
-     * const segments = { x: "1", y: "2" }
-     * const point = await format.segmentsToPoint(segments).value; // assumes success
-     * // point == { x: 1234, y: 5678, spatialReference: { ... }}
-     * ```
-     */
-    segmentsToPoint(segments: Record<string, string>): Promise<ParseResult<Point>>;
-}
-/**
- * A coordinate segment within a {@link SegmentedFormat}.
- */
-interface CoordinateSegment {
-    /**
-     * Id of this segment.
-     *
-     * This should be unique within the context of its format.
-     */
-    id: string;
-    /**
-     * Human readable label for this coordinate segment (e.g. "Latitude").
-     */
-    label: string;
-    /**
-     * Example for this segment, like '51° 57' 40"N'
-     */
-    example?: string;
-    /**
-     * A prefix value that will be shown as part of the input field for this coordinate segment.
-     *
-     * This is a display-only field for strings that do not need to be typed by the user (such as "°").
-     */
-    prefix?: string;
-    /**
-     * A suffix value that will be shown as part of the input field for this coordinate segment.
-     *
-     * This is a display-only field for strings that do not need to be typed by the user (such as "°").
-     */
-    suffix?: string;
-    /**
-     * Validates an input string for this coordinate segment.
-     * `input` is the (trimmed) text typed by the user.
-     *
-     * This function should return `true` if the input is valid,
-     * or an error message otherwise.
-     *
-     * `validate()` usually only performs text based validation (e.g. regular expressions).
-     * Parsing the actual input string (using {@link SegmentedFormat.segmentsToPoint}) can return additional errors.
-     *
-     * Only valid inputs will be passed to {@link SegmentedFormat.segmentsToPoint}.
-     */
-    validate(input: string): true | false | ParseError;
-}
-/**
- * A model that provides access to the current state of the coordinate conversion widget.
- * Properties and methods are designed to be used together with the Reactivity API.
- *
- * It is available as service `coordinateconversion.Model`.
- */
-interface CoordinateConversionModel {
-    /**
-     * True if the widget is currently active.
-     */
-    readonly active: boolean;
-    /**
-     * The current marker location, if any.
-     * This value represents explicit location inputs and also locations from mouse movements.
-     */
-    readonly currentLocation: Point | undefined;
-    /**
-     * The current marker location, if any.
-     *
-     * This value represents explicit location inputs only, i.e. if the user clicked on the map (not just moving the mouse)
-     * or confirmed the input form.
-     */
-    readonly confirmedLocation: Point | undefined;
-}
-
-export type { CoordinateConversionModel, CoordinateSegment, ParseError, ParseResult, ParseSuccess, SegmentedFormat };

package/coordinateconversion/package.json

@@ -1,5 +0,0 @@
-{
-    "name": "coordinateconversion",
-    "version": "4.19.3-SNAPSHOT",
-    "types": ""
-}