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

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";

package/test-utils/waitForProperty.d.ts

@@ -0,0 +1,27 @@
+export default waitForProperty;
+/**
+ * Helper to wait until expected property state is resolved.
+ *
+ * @function
+ * @alias module:waitForProperty
+ * @param {Mutable|Accessor|Stateful} mutable instance which property is observed.
+ * @param {String} property name of the property to wait for.
+ * @param {Function|undefined|value} [comparatorOrExpectedValue] comparator function which tests the given value state, or a value to wait for.
+ * If undefined the method will resolve if the property value is not undefined and not null.
+ * @param {Object} [config] config object. Currently only a timeout can be configured. The default timeout is 10000msec.
+ * @returns {Promise<any>} promise the promise which transports the property value.
+ * @example
+ *   const watchable = new Watchable();
+ *   watchable.property = 0;
+ *   setTimeout(()=>{
+ *     watchable.property = 1;
+ *   });
+ *
+ *   // block until property has value 1
+ *   const value = await waitForProperty(watchable, "property",
+ *                           (v) => v === 1,
+ *                           {timeout:100});
+ *   assert.equal(value, 1);
+ */
+declare function waitForProperty(mutable: Mutable | Accessor | Stateful, property: string, comparatorOrExpectedValue?: Function | undefined | value, { timeout }?: Object | undefined): Promise<any>;
+import Promise from "apprt-core/CancelablePromise";

package/theme-tester/test-layout/test-layout.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/themes/Theme.d.ts

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

package/themes/ThemeBundleListener.d.ts

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

package/themes/ThemeEventBroadCaster.d.ts

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

package/themes/ThemeModel.d.ts

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

package/themes/ThemeSelector.d.ts

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

package/themes/ThemeStyleWriter.d.ts

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

package/themes/popup.d.ts

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

package/toc/BaseTocItemFactory.d.ts

@@ -1,3 +1,4 @@
 export default class BaseTocItemFactory {
-    createBinding(targetViewModel: any, basemapsModel: any): import("apprt-binding/Binding").Binding;
+    createBinding(targetViewModel: any, basemapsModel: any): Binding;
 }
+import Binding from "apprt-binding/Binding";

package/toc/model/TocItem.d.ts

@@ -10,10 +10,11 @@ export namespace LIST_MODES {
     const hideChildren: string;
 }
 export default class TocItem {
-    constructor({ id, ref, title, visible, open, type, loaded, thumbnailUrl, listMode, legendEnabled, childrenToggleMode, children }?: {
+    constructor({ id, ref, title, supportsVisibility, visible, open, type, loaded, thumbnailUrl, listMode, legendEnabled, childrenToggleMode, children }?: {
         id: any;
         ref: any;
         title?: string | undefined;
+        supportsVisibility?: boolean | undefined;
         visible?: boolean | undefined;
         open?: boolean | undefined;
         type?: string | undefined;
@@ -29,6 +30,7 @@ export default class TocItem {
     title: string;
     type: string;
     childrenToggleMode: string;
+    supportsVisibility: boolean;
     loaded: boolean;
     visible: boolean;
     open: boolean;

package/toolrules/StoreToolRuleProcessor.d.ts

@@ -1,2 +1,11 @@
-declare var _default: any;
-export default _default;
+export default class StoreToolRuleProcessor {
+    rulePostFix: string;
+    toolRuleContext: any;
+    ruleProperties: any[];
+    useInCounter: {};
+    addStore(store: any, properties: any): void;
+    removeStore(store: any, properties: any): void;
+    _addUseInType(useInType: any): void;
+    _removeUseInType(useInType: any): void;
+    isRuleFulfilled(tool: any, context: any, toolRuleDef: any): any[];
+}

package/toolrules/ToolActiveStateManager.d.ts

@@ -1,2 +1,42 @@
-declare var _default: any;
-export default _default;
+declare const ToolActiveStateManager_base: any;
+/**
+ * @fileOverview  ToolActiveStateManager is responsible to evaluate tool active state rules (e.g. grouping).
+ * @author mre
+ */
+export default class ToolActiveStateManager extends ToolActiveStateManager_base {
+    [x: string]: any;
+    constructor(opts: any);
+    defaultActiveToolIds: any;
+    activateOnStartToolIds: any;
+    activateOnRegistrationToolIds: any;
+    toolsGroupLookup: {};
+    activeTools: Set<any>;
+    _onStartActivatedTools: any[];
+    _toolById: {};
+    /**
+     * Gets an array of all currently active tools.
+     */
+    getActiveTools(): any[];
+    deactivate(): void;
+    addTool(tool: any): void;
+    _addToolToGroup(tool: any): void;
+    _toolActiveStateChanged(evt: any): void;
+    _reactOnToolActiveState(tool: any, active: any): void;
+    _ensureThatGroupConditionIsFulfilled(groups: any): void;
+    _registerActiveTool(tool: any): void;
+    _unregisterActiveTool(tool: any): void;
+    _disableAllOtherTools(activeTool: any): any[];
+    _inDisableAllOtherTools: boolean | undefined;
+    _isDefaultActiveTool(tool: any): boolean;
+    _enableDefaultActiveToolInGroups(groups: any): void;
+    _findDefaultActiveToolsInGroups(groups: any): any[];
+    removeTool(tool: any): void;
+    _removeFromGroup(tool: any): void;
+    _getToolGroups(tool: any): any[];
+    _getActiveToolsInGroups(toolGroups: any): any[];
+    _getActiveToolsInGroupsOfTool(referenceTool: any): any[];
+    _checkActivateOnStartUp(tool: any): void;
+    _enableToolsOnStartup(): void;
+    _activateOnStartUp_called: boolean | undefined;
+}
+export {};

package/toolrules/ToolEventRebroadcaster.d.ts

@@ -1,2 +1,14 @@
-declare var _default: any;
-export default _default;
+export default class ToolEventRebroadcaster {
+    constructor(opts: any);
+    eventService: any;
+    active: boolean;
+    defaultTopicBase: string;
+    _topicBase: any;
+    _topics: {};
+    activate(): void;
+    deactivate(): void;
+    addTool(tool: any): void;
+    removeTool(tool: any): void;
+    _broadcast(evt: any): void;
+    #private;
+}

package/toolrules/ToolRuleContext.d.ts

@@ -1,2 +1,18 @@
-declare var _default: any;
-export default _default;
+declare const ToolRuleContext_base: any;
+/**
+ * ToolRuleContext.
+ * Processors trigger a delayed rule evaluation by setting properties on the context.
+ */
+export default class ToolRuleContext extends ToolRuleContext_base {
+    [x: string]: any;
+    /**
+     * Forces an tool rule evaluation -> synchronous!
+     * Use this rare!
+     * And only if really really required!
+     * Tool rule evaluation is an expensive operation, that is why it is delayed by default.
+     * @properties name of the context properties which trigger the reevaluation. This should provide a way for future
+     * performance improvements.
+     */
+    forceEvaluation(properties: any): void;
+}
+export {};