@conterra/ct-mapapps-typings 4.13.0 → 4.13.2-PRE-1

package/selection-services/module.d.ts

@@ -1 +1,5 @@
-export {};
+export { default as DrawingSpatialInputActionRegistrator } from "./DrawingSpatialInputActionRegistrator";
+export { default as SpatialInputActionService } from "./SpatialInputActionService";
+export { default as SearchSourceModel } from "./SearchSourceModel";
+export { default as SpatialSearchService } from "./SpatialSearchService";
+export { default as SelectionTriggerFactory } from "./SelectionTriggerFactory";

package/selection-tools/ToolCommand.d.ts

@@ -7,7 +7,7 @@ declare class Command {
     _actionOptions: any;
     _deactivateOnSelection: any;
     _searchAllSources: boolean;
-    _binding: import("../../apprt/apprt-binding/Binding").Binding;
+    _binding: Binding;
     start({ tool }: {
         tool: any;
     }): void;
@@ -16,3 +16,4 @@ declare class Command {
         tool: any;
     }): void;
 }
+import Binding from "apprt-binding/Binding";

package/selection-tools/ToolItem.d.ts

@@ -1,12 +1,12 @@
 export default ToolItem;
-declare const ToolItem: import("../../apprt/apprt-core/Mutable").MutableConstructor<{
-    id: string | String | undefined;
-    title: string | String | undefined;
-    description: string | String | undefined;
-    iconClass: string | String | undefined;
-    selectionMethod: string | String | undefined;
+declare const ToolItem: import("apprt-core/Mutable").MutableConstructor<{
+    id: string | undefined;
+    title: string | undefined;
+    description: string | undefined;
+    iconClass: string | undefined;
+    selectionMethod: string | undefined;
     selectionOptions: {} | undefined;
-    sourceIds: any;
+    sourceIds: any[] | undefined;
     sourceId: any;
     effectiveMethod: any;
     effectiveSourceIds: any;

package/selection-tools/ToolRegistry.d.ts

@@ -1,5 +1,5 @@
 export default ToolRegistry;
-declare const ToolRegistry: import("../../apprt/apprt-core/Mutable").MutableConstructor<{
+declare const ToolRegistry: import("apprt-core/Mutable").MutableConstructor<{
     [_items]: never[] | undefined;
     items: any;
     add: (item: any) => void;

package/selection-tools/ToolRegistryTracker.d.ts

@@ -15,4 +15,4 @@ declare class ToolRegistryTracker {
     _register(toolItem: any): void;
     _unregister(id: any): void;
 }
-import TaskExecutor from "../../apprt/apprt-core/TaskExecutor";
+import TaskExecutor from "apprt-core/TaskExecutor";

package/selection-tools/module.d.ts

@@ -1 +1,3 @@
-export {};
+export { default as Config } from "./Config";
+export { default as ToolRegistry } from "./ToolRegistry";
+export { default as ToolRegistryTracker } from "./ToolRegistryTracker";

package/selection-ui/module.d.ts

@@ -1 +1 @@
-export {};
+export { default as Config } from "./Config";

package/selection-ui-config/module.d.ts

@@ -1 +1 @@
-export {};
+export { default as DataFormBuilderWidgetFactory } from "./DataFormBuilderWidgetFactory";

package/share-link-shim/WebShareUI.d.ts

@@ -17,4 +17,4 @@ declare class WebShareUI {
     _hide(): void;
     _hideTimer: NodeJS.Timeout | undefined;
 }
-import Promise from "../../apprt/apprt-core/Promise";
+import Promise from "apprt-core/Promise";

package/sketching/Sketching.d.ts

@@ -6,7 +6,7 @@ export default class Sketching {
     } | undefined;
     isEnabled(): boolean;
     enable(): void;
-    _observers: import("../../../apprt/apprt-core/Observers").Observers | undefined;
+    _observers: import("apprt-core/Observers").Observers | undefined;
     _sketchViewModel: SketchViewModel | undefined;
     disable(): void;
     activateSketchTool({ mode }: {

package/sketching/module.d.ts

@@ -1 +1 @@
-export {};
+export { default as Sketching } from "./Sketching";

package/store-api/QueryExecution.d.ts

@@ -88,6 +88,6 @@ declare type QueryExecutionConstructorOptions<T> = Partial<Pick<QueryExecution<T
  *  ```
  */
 export declare type QueryExecutionConstructor<T> = new (options?: QueryExecutionConstructorOptions<T>) => QueryExecution<T>;
-declare const _default: QueryExecutionConstructor<unknown>;
 /** Creates a QueryExecution */
+declare const _default: QueryExecutionConstructor<unknown>;
 export default _default;

package/store-api/QueryExecutions.d.ts

@@ -39,8 +39,8 @@ export interface QueryExecutions extends Watchable {
  * @param options Options that contain the query executions to add to the collection.
  */
 export declare type QueryExecutionsConstructor = new (options?: QueryExecutionsConstructorOptions) => QueryExecutions;
-declare const _default: QueryExecutionsConstructor;
 /**
  * Creates QueryExecutions.
  */
+declare const _default: QueryExecutionsConstructor;
 export default _default;

package/store-api/api/Store.d.ts

@@ -9,7 +9,14 @@ export declare type IndexableThing = Readonly<Record<string, any>>;
 export interface ResultItems<ItemType extends IndexableThing> extends ReadonlyArray<ItemType> {
     /** Total number of available items in the result. */
     readonly total?: number;
-    /** Function to cancel the query. It is always 'undefined' in synchronous responses. */
+    /**
+     * Set to true by the store to indicate that there are more results.
+     * The client may query again with an appropriate `start` value.
+     */
+    readonly hasMore?: boolean;
+    /** Function to cancel the query. It is always 'undefined' in synchronous responses.
+     * @deprecated Use AbortOptions (AbortSignal)
+     */
     readonly cancel?: undefined;
     /** Function to react on the provided result. It is always 'undefined' in synchronous responses. */
     readonly then?: undefined;

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

@@ -81,6 +81,11 @@ export declare class BaseRestStore<ItemType extends IndexableThing, IDType exten
      * Configuration option for getMetadata method.
      */
     metadata: Partial<Metadata> | undefined;
+    /**
+     * Flag which indicates that an switching to POST is allowed when GET requests are to long.
+     * This is true by default for backwards compatibility.
+     */
+    supportsPostSwitching: boolean;
     /**
      * Property for sub classes which provide static pre-configured metadata template.
      */

package/style-guide/style-guide-layout/template.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="types/thirdparty" />
+/// <reference types="types/build-support" />
 declare namespace _default {
     export { templateStringContent as templateString };
     export namespace extend {
@@ -8,4 +8,4 @@ declare namespace _default {
     }
 }
 export default _default;
-import templateStringContent from "dojo/*";
+import templateStringContent from "text!*";

package/system/component/ComponentConstants.d.ts

@@ -1,4 +1,4 @@
-declare var _default: {
+declare const _default: {
     /**
      * A service registration property for a Component Factory that contains the
      * value of the factory attribute. The value of this property must be of type

package/system/component/ComponentException.d.ts

@@ -5,4 +5,4 @@ declare class ComponentException extends Exception {
 declare namespace ComponentException {
     const types: {};
 }
-import { default as Exception } from "../../apprt-core/Exception";
+import { default as Exception } from "apprt-core/Exception";

package/system/config/Configuration.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/system/config/ConfigurationAdmin.d.ts

@@ -81,7 +81,7 @@ export default class ConfigurationAdmin {
     _managedServices: {};
     _configInterceptors: Set<any>;
     _configPluginCounter: number;
-    _configPluginComparator: import("../../apprt-core/comparators").Comparator<{
+    _configPluginComparator: import("apprt-core/comparators").Comparator<{
         ranking: any;
     } & {
         ranking: any;

package/system/config/ConfigurationException.d.ts

@@ -2,4 +2,4 @@ export default ConfigurationException;
 declare class ConfigurationException extends Exception {
     constructor(name: any, message: any, cause: any);
 }
-import { default as Exception } from "../../apprt-core/Exception";
+import { default as Exception } from "apprt-core/Exception";

package/system/config/ConfigurationPlugin.d.ts

@@ -1,2 +1,84 @@
-declare var _default: any;
-export default _default;
+/**
+ * A service interface for processing configuration dictionary before the
+ * update.
+ *
+ * <p>
+ * A bundle registers a <code>ConfigurationPlugin</code> object in order to
+ * process configuration updates before they reach the Managed Service or
+ * Managed Service Factory. The Configuration Admin service will detect
+ * registrations of Configuration Plugin services and must call these services
+ * every time before it calls the <code>ManagedService</code> or
+ * <code>ManagedServiceFactory</code>
+ * <code>updated</code> method. The
+ * Configuration Plugin service thus has the opportunity to view and modify the
+ * properties before they are passed to the Managed Service or Managed Service
+ * Factory.
+ *
+ * <p>
+ * Configuration Plugin (plugin) services have full read/write access to all
+ * configuration information. Therefore, bundles using this facility should be
+ * trusted. Access to this facility should be limited with
+ * <code>ServicePermission[ConfigurationPlugin,REGISTER]</code>.
+ * Implementations of a Configuration Plugin service should assure that they
+ * only act on appropriate configurations.
+ *
+ * <p>
+ * The <code>Integer</code> <code>service.cmRanking</code> registration
+ * property may be specified. Not specifying this registration property, or
+ * setting it to something other than an <code>Integer</code>, is the same as
+ * setting it to the <code>Integer</code> zero. The
+ * <code>service.cmRanking</code> property determines the order in which
+ * plugins are invoked. Lower ranked plugins are called before higher ranked
+ * ones. In the event of more than one plugin having the same value of
+ * <code>service.cmRanking</code>, then the Configuration Admin service
+ * arbitrarily chooses the order in which they are called.
+ *
+ * <p>
+ * By convention, plugins with <code>service.cmRanking&lt; 0</code> or
+ * <code>service.cmRanking &gt; 1000</code> should not make modifications to
+ * the properties.
+ *
+ * <p>
+ * The Configuration Admin service has the right to hide properties from
+ * plugins, or to ignore some or all the changes that they make. This might be
+ * done for security reasons. Any such behavior is entirely implementation
+ * defined.
+ *
+ * <p>
+ * A plugin may optionally specify a <code>cm.target</code> registration
+ * property whose value is the PID of the Managed Service or Managed Service
+ * Factory whose configuration updates the plugin is intended to intercept. The
+ * plugin will then only be called with configuration updates that are targeted
+ * at the Managed Service or Managed Service Factory with the specified PID.
+ * Omitting the <code>cm.target</code> registration property means that the
+ * plugin is called for all configuration updates.
+ */
+export default class ConfigurationPlugin {
+    /**
+     * View and possibly modify the a set of configuration properties before
+     * they are sent to the Managed Service or the Managed Service Factory. The
+     * Configuration Plugin services are called in increasing order of their
+     * <code>service.cmRanking</code> property. If this property is undefined
+     * or is a non- <code>Integer</code> type, 0 is used.
+     *
+     * <p>
+     * This method should not modify the properties unless the
+     * <code>service.cmRanking</code> of this plugin is in the range
+     * <code>0 &lt;= service.cmRanking &lt;= 1000</code>.
+     * <p>
+     * If this method throws any <code>Exception</code>, the Configuration
+     * Admin service must catch it and should log it.
+     *
+     * @param targetInfo : {
+                            managedService : ..,
+                            managedServiceProperties: ..,
+                            pid: ..,
+                            factoryPid : ..
+                    }
+     * @param properties The configuration properties. This argument must not
+     *        contain the "service.bundleLocation" property. The value of this
+     *        property may be obtained from the
+     *        <code>Configuration.getBundleLocation</code> method.
+     */
+    modifyConfiguration(targetInfo: any, properties: any): void;
+}

package/system/config/ConfigurationStore.d.ts

@@ -1,2 +1,23 @@
-declare var _default: any;
-export default _default;
+declare const ConfigurationStore_base: any;
+/**
+ * Service for read/write configuration data.
+ * The store must currently be synchronous.
+ */
+export default class ConfigurationStore extends ConfigurationStore_base {
+    [x: string]: any;
+    _configs: any;
+    _factoryLookup: {};
+    searchConfigs(filter: any): any;
+    getFactoryConfigs(factoryPid: any): any[];
+    getConfig(pid: any): any;
+    /**
+     * Updates a configuration instance.
+     */
+    setConfig(pid: any, config: any): void;
+    /**
+     * Removes/deletes a configuration instance.
+     */
+    removeConfig(pid: any): void;
+    onConfigChanged(): void;
+}
+export {};

package/system/config/DefaultPersistencePlugin.d.ts

@@ -2,5 +2,5 @@
  * @fileOverview Responsible to write app.json into builder service.
  */
 export default class DefaultPersistencePlugin {
-    save(item: any): Promise<any>;
+    save(item: any): Promise<unknown>;
 }

package/system/config/JSONConfigurationAdapter.d.ts

@@ -1,2 +1,36 @@
-declare var _default: any;
-export default _default;
+/**
+ * Provides a view from the config store to more human readable JSON structure.
+ *
+ * Service for read/write configuration data.
+ * The store must be synchronous.
+ */
+export default class JsonConfigurationAdapter {
+    activate(cpCtx: any): void;
+    _bundleContext: any;
+    jsonConfig: any;
+    appLocation: any;
+    deactivate(): void;
+    createInstance(): JsonConfigurationStore;
+    store: JsonConfigurationStore | null | undefined;
+    destroyInstance(): void;
+    _convertRootConfigToConfigStoreItems(jsonConfig: any, store: any): void;
+    _convertBundleConfigToStoreItems(bundleName: any, bundleConfigObj: any, store: any): void;
+    _convertComponentConfigToStoreItems(bundleName: any, componentName: any, componentProps: any, store: any): void;
+    _createStoreItem(isFactory: any, bundleName: any, componentName: any, props: any, facItemCounter: any): {
+        pid: any;
+        bundleIdentifier: any;
+        properties: any;
+    } | undefined;
+}
+declare class JsonConfigurationStore extends ConfigurationStore {
+    constructor(opts: any);
+    appLocation: any;
+    jsonConfig: any;
+    _bundleContext: any;
+    getAppConfig(): any;
+    save(): any;
+    _buildBundlesSectionFromStoreEntries(): {};
+    _persistEnabledState(jsonConfig: any): void;
+}
+import ConfigurationStore from "./ConfigurationStore";
+export {};

package/system/config/ManagedService.d.ts

@@ -1,2 +1,113 @@
-declare var _default: any;
-export default _default;
+/**
+ * A service that can receive configuration data from a Configuration Admin
+ * service.
+ *
+ * <p>
+ * A Managed Service is a service that needs configuration data. Such an object
+ * should be registered with the Framework registry with the
+ * <code>service.pid</code> property set to some unique identifier called a
+ * PID.
+ *
+ * <p>
+ * If the Configuration Admin service has a <code>Configuration</code> object
+ * corresponding to this PID, it will callback the <code>updated()</code>
+ * method of the <code>ManagedService</code> object, passing the properties of
+ * that <code>Configuration</code> object.
+ *
+ * <p>
+ * If it has no such <code>Configuration</code> object, then it calls back
+ * with a <code>null</code> properties argument. Registering a Managed Service
+ * will always result in a callback to the <code>updated()</code> method
+ * provided the Configuration Admin service is, or becomes active. This callback
+ * must always be done asynchronously.
+ *
+ * <p>
+ * Else, every time that either of the <code>updated()</code> methods is
+ * called on that <code>Configuration</code> object, the
+ * <code>ManagedService.updated()</code> method with the new properties is
+ * called. If the <code>delete()</code> method is called on that
+ * <code>Configuration</code> object, <code>ManagedService.updated()</code>
+ * is called with a <code>null</code> for the properties parameter. All these
+ * callbacks must be done asynchronously.
+ *
+ * <p>
+ * The following example shows the code of a serial port that will create a port
+ * depending on configuration information.
+ *
+ * <pre>
+ *
+ *   class SerialPort implements ManagedService {
+ *
+ *     ServiceRegistration registration;
+ *     Hashtable configuration;
+ *     CommPortIdentifier id;
+ *
+ *     synchronized void open(CommPortIdentifier id,
+ *     BundleContext context) {
+ *       this.id = id;
+ *       registration = context.registerService(
+ *         ManagedService.class.getName(),
+ *         this,
+ *         getDefaults()
+ *       );
+ *     }
+ *
+ *     Hashtable getDefaults() {
+ *       Hashtable defaults = new Hashtable();
+ *       defaults.put( &quot;port&quot;, id.getName() );
+ *       defaults.put( &quot;product&quot;, &quot;unknown&quot; );
+ *       defaults.put( &quot;baud&quot;, &quot;9600&quot; );
+ *       defaults.put( Constants.SERVICE_PID,
+ *         &quot;com.acme.serialport.&quot; + id.getName() );
+ *       return defaults;
+ *     }
+ *
+ *     public synchronized void updated(
+ *       Dictionary configuration  ) {
+ *       if ( configuration ==  null)
+ *         registration.setProperties( getDefaults() );
+ *       else {
+ *         setSpeed( configuration.get(&quot;baud&quot;) );
+ *         registration.setProperties( configuration );
+ *       }
+ *     }
+ *     ...
+ *   }
+ *
+ * </pre>
+ *
+ * <p>
+ * As a convention, it is recommended that when a Managed Service is updated, it
+ * should copy all the properties it does not recognize into the service
+ * registration properties. This will allow the Configuration Admin service to
+ * set properties on services which can then be used by other applications.
+ */
+export default class ManagedService {
+    /**
+     * Update the configuration for a Managed Service.
+     *
+     * <p>
+     * When the implementation of <code>updated(Dictionary)</code> detects any
+     * kind of error in the configuration properties, it should create a new
+     * <code>ConfigurationException</code> which describes the problem. This
+     * can allow a management system to provide useful information to a human
+     * administrator.
+     *
+     * <p>
+     * If this method throws any other <code>Exception</code>, the
+     * Configuration Admin service must catch it and should log it.
+     * <p>
+     * The Configuration Admin service must call this method asynchronously
+     * which initiated the callback. This implies that implementors of Managed
+     * Service can be assured that the callback will not take place during
+     * registration when they execute the registration in a synchronized method.
+     *
+     * @param properties A copy of the Configuration properties, or
+     *        <code>null</code>. This argument must not contain the
+     *        "service.bundleLocation" property. The value of this property may
+     *        be obtained from the <code>Configuration.getBundleLocation</code>
+     *        method.
+     * @throws ConfigurationException when the update fails
+     */
+    updated(properties: any): void;
+}

package/system/config/ManagedServiceFactory.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/system/user/User.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/system/user/UserEventRebroadcaster.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/template-appsoverview/template.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="types/thirdparty" />
+/// <reference types="types/build-support" />
 declare namespace _default {
     export { template as templateString };
     export namespace extend {
@@ -7,4 +7,4 @@ declare namespace _default {
     }
 }
 export default _default;
-import template from "dojo/*";
+import template from "text!*";

package/template-seasons/seasons.d.ts

@@ -25,17 +25,17 @@ declare namespace _default {
     const layouts: ({
         requiredExecutionEnvironment: string[];
         orientation: string;
-        templateString: any;
+        templateString: string;
         name: string;
         maxWidth?: undefined;
     } | {
         maxWidth: number;
         orientation: string;
-        templateString: any;
+        templateString: string;
         name: string;
         requiredExecutionEnvironment?: undefined;
     } | {
-        templateString: any;
+        templateString: string;
         name: string;
         requiredExecutionEnvironment?: undefined;
         orientation?: undefined;

package/templatelayout/AppRootSizeController.d.ts

@@ -1,2 +1,10 @@
-declare var _default: any;
-export default _default;
+declare const AppRootSizeController_base: any;
+export default class AppRootSizeController extends AppRootSizeController_base {
+    [x: string]: any;
+    activate(): void;
+    resize(): void;
+    root: any;
+    _orientSize: {} | undefined;
+    deactivate(): void;
+}
+export {};

package/templatelayout/DefaultLayoutBreakPoints.d.ts

@@ -1,4 +1,4 @@
-declare var _default: ({
+declare const _default: ({
     minWidth: number;
     orientation: string;
     name: string;

package/templatelayout/DojoClickPatch.d.ts

@@ -1,2 +1,2 @@
-declare var _default: {};
+declare const _default: {};
 export default _default;

package/templatelayout/LayoutState.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/templatelayout/LayoutTemplateToolRuleProcessor.d.ts

@@ -1,2 +1,14 @@
-declare var _default: any;
-export default _default;
+/**
+ * LayoutTemplateToolRuleProcessor is a rule to match against the currently enabled sub-layout or layout template.
+ */
+export default class LayoutTemplateToolRuleProcessor {
+    ruleProperties: string[];
+    ruleContextState: null;
+    activate(): void;
+    /**
+     * Method is called by the ToolRule Manager.
+     */
+    isRuleFulfilled(tool: any, context: any, toolRuleDef: any): any[];
+    _matches(ruleNames: any, ruleValue: any, results: any): void;
+    _layoutStateChange(): void;
+}

package/templatelayout/WidgetDefinitions.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/templatelayout-dijit/TemplateRenderer.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/templatelayout-dijit/TemplateWidget.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/templates/Template.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/templates/TemplateEventBroadCaster.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/templates/TemplateModel.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/templates/TemplateSelector.d.ts

@@ -1,2 +1,2 @@
-declare var _default: any;
+declare const _default: any;
 export default _default;

package/test-utils/later.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Helper for tests to check states a little bit later in time.
+ *
+ * @function
+ * @param {Function | Number} [cb] callback which will be triggered later.
+ * @param {Number} [delay] optional delay
+ * @returns {Promise} promise
+ * @example
+ * import {later} from "test-utils/later";
+ *
+ * function "expect something"(){
+ *      // code...
+ *      return later(()=>{
+ *          // check state
+ *      });
+ * }
+ */
+export function later(cb?: number | Function | undefined, delay?: number | undefined): Promise<any>;
+/**
+ * Helper to bind 'later' to custom delay.
+ *
+ * @function
+ * @param {Number} delay
+ * @returns {Function} custom later function.
+ * @example
+ * import { customDelay } from "test-utils/later";
+ *
+ * const later = customDelay(50);
+ *
+ * function "expect something"(){
+ *      // code...
+ *      return later(()=>{
+ *          // check state
+ *      });
+ * }
+ */
+export function customDelay(delay: number): Function;
+export default later;
+import Promise from "apprt-core/Promise";