@conterra/ct-mapapps-typings 4.14.2 → 4.15.0-next.20230120041840

package/agssearch/AGSSearchInterpreter.d.ts

@@ -1,8 +1,7 @@
-export class AGSSearchInterpreter {
-    set _filterStoreFactory(arg: any);
-    interpret(configFragment: any): Promise<{
-        apply: () => void;
-        dispose: () => void;
-    } | undefined>;
+import { ConfigFragment, ConfigFragmentInterpreter, Disposable } from "domains-system/api";
+import type { FilterStoreFactory } from "./FilterStoreFactory";
+export declare class AGSSearchInterpreter implements ConfigFragmentInterpreter {
     #private;
+    set _filterStoreFactory(value: FilterStoreFactory);
+    interpret(configFragment: ConfigFragment): Promise<Disposable | void>;
 }

package/agssearch/AGSSearchMerger.d.ts

@@ -1,4 +1,10 @@
-export function AGSSearchMerger(storeFactory: any, bundleContext: any, configuration: any): {
-    apply: () => void;
-    dispose: () => void;
-};
+export interface AGSSearchMerger {
+    apply(): void;
+    dispose(): void;
+}
+export interface SearchConfiguration {
+    id: string;
+}
+export declare function createAGSSearchMerger(storeFactory: any, // TODO(typings)
+bundleContext: any, // TODO(typings)
+configuration: SearchConfiguration[]): AGSSearchMerger;

package/agssearch/AGSStoreFactory.d.ts

@@ -1,29 +1,11 @@
+import type { AGSStore, AGSStoreFactory as AGSStoreFactoryInterface, AGSStoreFromLayerOptions, AGSStoreFromURLOptions } from "./api";
 /**
  * Factory class that creates store instances.
  */
-export class AGSStoreFactory {
-    /**
-     * Creates a new store instance backed by an ArcGIS Feature Server or Map Server.
-     * Either the `layerId` parameter or the `url` parameter must be specified.
-     *
-     * @param {Object} options
-     * @param {string} [options.id] The id of the new store
-     * @param {string} [options.layerId] A valid layer or sublayer id
-     * @param {string} [options.url] A service url, for services that are not in the map
-     * @param {boolean} [options.legacyImplementation]
-     *      Set this value to `true` to use the deprecated old MapServerLayerStore implementation
-     *      instead of the new LayerStore.
-     * @returns A promise that resolves to the new store instance
-     */
-    createStore(options: {
-        id?: string | undefined;
-        layerId?: string | undefined;
-        url?: string | undefined;
-        legacyImplementation?: boolean | undefined;
-    }): Promise<LayerStore<import("./LayerStore").SupportedLayerType> | MapServerLayerStore>;
-    _createLegacyStore(layerId: any, options: any): MapServerLayerStore;
-    _createLayerStore(layerId: any, target: any, options: any): Promise<LayerStore<import("./LayerStore").SupportedLayerType>>;
-    _getServiceInfoFromMap(layerId: any): any;
+export declare class AGSStoreFactory implements AGSStoreFactoryInterface {
+    private _mapWidgetModel;
+    createStore(options: AGSStoreFromLayerOptions | AGSStoreFromURLOptions): Promise<AGSStore>;
+    private _createLayerStore;
+    private _createLegacyStore;
+    private _getServiceInfoFromMap;
 }
-import { LayerStore } from "./LayerStore";
-import MapServerLayerStore from "ct/mapping/store/MapServerLayerStore";

package/agssearch/AutoStoreRegistration.d.ts

@@ -1,20 +1,20 @@
-export class AutoStoreRegistration {
-    _observers: import("apprt-core/Observers").Observers;
-    _storeRegistrations: Map<any, any>;
+export declare class AutoStoreRegistration {
+    private _observers;
+    private _storeRegistrations;
+    private _map;
+    private _agsStoreFactory;
+    private _bundleContext;
+    private _useLegacyImplementation;
+    private _delay;
     activate(componentContext: any): void;
-    _bundleContext: any;
-    _delay: any;
-    _useLegacyImplementation: any;
-    _observeMap(): void;
-    _observeLayer(layer: any, callback: any): {
-        remove: () => void;
-    };
-    _checkServiceLayer(layer: any, id: any): void;
-    _observeServiceLayer(rootLayer: any, id: any): void;
-    _checkSublayer(layer: any, id: any): void;
-    _delayedRegisterStore(layer: any, id: any): void;
-    _delayedUnregisterStore(layer: any): void;
-    _registerStore(layer: any, id: any, registerId: any): Promise<void>;
-    _unregisterStore(layer: any, id: any, registerId: any): void;
     deactivate(): void;
+    private _observeMap;
+    private _observeLayer;
+    private _checkServiceLayer;
+    private _observeServiceLayer;
+    private _checkSublayer;
+    private _delayedRegisterStore;
+    private _delayedUnregisterStore;
+    private _registerStore;
+    private _unregisterStore;
 }

package/agssearch/FilterStoreFactory.d.ts

@@ -1,14 +1,21 @@
-export function FilterStoreFactory(): {
+export declare class FilterStoreFactory {
+    #private;
+    private _mapWidgetModel;
+    private _agsStoreFactory;
+    private _logger;
+    private _i18n;
+    private _properties;
+    private _componentContext;
     activate(): void;
-    _initStore(): any;
-    _logError(id: any, error: any): any;
-    _observeLayer(layerId: any): void;
-    _buildLayerObserver(mapWidgetModel: any, path: any): import("map-widget/LayerObserver").LayerObserver;
-    _trackLayerChange(path: any, layer: any, removed: any): void;
-    _trackSublayerChange(layer: any, subLayerId: any): void;
-    _trackVisibilityChanges(layerOrSublayer: any): void;
-    _checkStoreRegistrationStateAsync(targetLayer: any): void;
-    _checkStoreRegistrationState(targetLayer: any): void;
     deactivate(): void;
-    _register(store: any, props: any, targetLayer: any, nonFilteredStore: any): void;
-};
+    private _initStore;
+    private _logError;
+    private _observeLayer;
+    private _buildLayerObserver;
+    private _trackLayerChange;
+    private _trackSublayerChange;
+    private _trackVisibilityChanges;
+    private _checkStoreRegistrationStateAsync;
+    private _checkStoreRegistrationState;
+    private _register;
+}

package/agssearch/LayerStore.d.ts

@@ -1,10 +1,9 @@
 /// <reference types="arcgis-js-api" />
+import { SpatialReference } from "esri/geometry";
 import FeatureLayer from "esri/layers/FeatureLayer";
 import type Sublayer from "esri/layers/support/Sublayer";
 import type Map from "esri/Map";
-import type { ComplexQueryExpression } from "store-api/api/ComplexQueryLang";
-import type { AsyncStore, GetOptions, Metadata, QueryOptions, AsyncQueryResult } from "store-api/api/Store";
-import { SpatialReference } from "esri/geometry";
+import type { ComplexQueryExpression, AsyncQueryResult, AsyncStore, GetOptions, Metadata, QueryOptions } from "store-api/api";
 export interface LayerStoreMetadata extends Metadata {
     /** The feature id property name. Same as store.idProperty. */
     readonly idProperty: string;
@@ -17,11 +16,11 @@ export interface LayerStoreMetadata extends Metadata {
      */
     readonly spatialReference: SpatialReference;
 }
-declare type FeatureLayerProps = "type" | "destroy" | "load" | "loaded" | "url" | "layerId" | "capabilities" | "sourceJSON" | "objectIdField" | "title" | "displayField" | "geometryType" | "fullExtent" | "popupTemplate" | "fields" | "createQuery" | "queryObjectIds" | "queryFeatures" | "queryFeatureCount" | "definitionExpression" | "spatialReference";
-export declare type SimpleFeatureLayer = Pick<FeatureLayer, FeatureLayerProps>;
-declare type Feature = Record<string, any>;
-declare type FeatureId = string | number;
-export declare type SupportedLayerType = SimpleFeatureLayer | Sublayer;
+type FeatureLayerProps = "type" | "destroy" | "load" | "loaded" | "url" | "layerId" | "capabilities" | "sourceJSON" | "objectIdField" | "title" | "displayField" | "geometryType" | "fullExtent" | "popupTemplate" | "fields" | "createQuery" | "queryObjectIds" | "queryFeatures" | "queryFeatureCount" | "definitionExpression" | "spatialReference";
+export type SimpleFeatureLayer = Pick<FeatureLayer, FeatureLayerProps>;
+type Feature = Record<string, any>;
+type FeatureId = string | number;
+export type SupportedLayerType = SimpleFeatureLayer | Sublayer;
 /**
  * A store implementation that searches directly on an ArcGIS Feature Layer object.
  */

package/agssearch/StoreInitializer.d.ts

@@ -1,7 +1,14 @@
-export function StoreInitializer(opts: any): {
-    init(props: any): globalThis.Promise<{
-        store: any;
-        nonFilteredStore: any;
-        props: any;
-    }>;
-};
+import { AGSStore, AGSStoreFactory } from "./api";
+export interface StoreInitializer {
+    init(props: Record<string, any>): Promise<StoreInitializerResult>;
+}
+export interface StoreInitializerOptions {
+    fac: AGSStoreFactory;
+    defaults: Record<string, any>;
+}
+export interface StoreInitializerResult {
+    store: AGSStore;
+    nonFilteredStore: AGSStore;
+    props: Record<string, any>;
+}
+export declare function createStoreInitializer(opts: StoreInitializerOptions): StoreInitializer;

package/agssearch/api.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Provides an API to create custom store instances.
+ *
+ * @example
+ * Use the service name `agssearch.AGSStoreFactory` to obtain a {@link AGSStoreFactory} reference for your component:
+ * ```js
+ * "components": [
+ *     {
+ *         "name": "MyExampleComponent",
+ *         "references": [
+ *             {
+ *                 "name": "_storeFactory",
+ *                 "providing": "agssearch.AGSStoreFactory"
+ *             }
+ *         ]
+ *     }
+ * ]
+ * ```
+ *
+ * @example
+ * Use the obtained {@link AGSStoreFactory} to create new store instances.
+ *  ```js
+ *  class MyExampleComponent {
+ *     async exampleMethod() {
+ *         const store = await this._storeFactory.createStore({
+ *             id: "my-new-store",
+ *             layerId: "a-valid-layer-id"
+ *             // or url: "https://example.com/some/FeatureServer"
+ *         });
+ *     }
+ * }
+ * ```
+ *
+ * @module
+ */
+import { AsyncStore } from "store-api/api";
+/**
+ * Factory used to created new store instances.
+ *
+ * Use service name `"agssearch.AGSStoreFactory"` to inject an instance of this factory.
+ */
+export interface AGSStoreFactory {
+    /**
+     * Creates a new store instance backed by an ArcGIS Feature Server or Map Server.
+     * Either the `layerId` parameter or the `url` parameter must be specified.
+     *
+     * @example
+     * ```ts
+     * const store = await this._storeFactory.createStore({
+     *     id: "my-new-store",
+     *     layerId: "a-valid-layer-id"
+     *     // or url: "https://example.com/some/FeatureServer"
+     * });
+     * ```
+     */
+    createStore(options: AGSStoreFromLayerOptions | AGSStoreFromURLOptions): Promise<AGSStore>;
+}
+/**
+ * Properties supported by AGSStores.
+ */
+export interface AGSStoreCommonOptions {
+    /**  The id of the new store. */
+    id: string;
+    /**
+     * Set this value to `true` to use the deprecated old MapServerLayerStore implementation
+     * instead of the new LayerStore.
+     */
+    legacyImplementation?: boolean;
+}
+/**
+ * Specifies an AGSStore constructed from a layer or sublayer id.
+ */
+export interface AGSStoreFromLayerOptions extends AGSStoreCommonOptions {
+    /** A valid layer id (e.g. `"mylayer"`) or sub layer id (e.g. `"mylayer/1"`). */
+    layerId: string;
+}
+/**
+ * Specifies an AGSStore constructed from a URL.
+ */
+export interface AGSStoreFromURLOptions extends AGSStoreCommonOptions {
+    /** A service url, for services that are not in the map. */
+    url: string;
+}
+/**
+ * The type of stores created by the {@link AGSStoreFactory}.
+ */
+export interface AGSStore extends AsyncStore {
+    /**
+     * The URL of the layer queried by this store.
+     * Undefined if this store works on a client side layer.
+     */
+    url: string | undefined;
+    /** @deprecated Use {@link url} instead. */
+    target: string | undefined;
+}

package/agssearch/util.d.ts

@@ -1,4 +1,5 @@
-export function parseLayerPath(layerPath: any): {
+export interface LayerPath {
     layerId: string | undefined;
     subLayerId: string | undefined;
-} | undefined;
+}
+export declare function parseLayerPath(layerPath: string): LayerPath | undefined;

package/apprt/Constants.d.ts

@@ -1,5 +1,4 @@
 declare namespace _default {
-    function SERVICE_REFERENCE_COMPARATOR(a: any, b: any): number;
     function SERVICE_REFERENCE_COMPARATOR(a: any, b: any): number;
     const SYSTEM_BUNDLE_LOCATION: string;
     const SYSTEM_BUNDLE_SYMBOLICNAME: string;

package/apprt-binding/Bindable.d.ts

@@ -6,7 +6,7 @@ export interface WatchHandle {
     /** Unregister the watch handle */
     remove(): void;
 }
-export declare type WatchCallback = () => void;
+export type WatchCallback = () => void;
 /**
  * The interface that must be implemented by the left and right side objects of a Binding.
  * Methods of this interface enable the synchronization of watches by making properties reactive:
@@ -52,4 +52,4 @@ export interface BindableInterface {
  * If BindableInterface is used directly, the compiler complains because of "no common properties":
  * https://stackoverflow.com/questions/46449237/type-x-has-no-properties-in-common-with-type-y
  */
-export declare type Bindable = BindableInterface & Record<string, any>;
+export type Bindable = BindableInterface & Record<string, any>;

package/apprt-binding/Binding.d.ts

@@ -19,7 +19,7 @@ export * from "./Bindable";
  * });
  * ```
  */
-export declare type ConvertFunction = (newValue: any, context: Context) => any;
+export type ConvertFunction = (newValue: any, context: Context) => any;
 /**
  * The Context is available in conversion functions.
  */
@@ -57,7 +57,7 @@ export interface Context {
      */
     promiseValue<T>(candidate: PromiseLike<T>): any;
 }
-export declare type PropertyName = string | symbol;
+export type PropertyName = string | symbol;
 /**
  * Class for two way binding between bindables.
  */

package/apprt-binding/PropertyAccess.d.ts

@@ -4,10 +4,10 @@ declare const ACCESS_IN_INSTANCE_KEY: unique symbol;
 declare const _state: unique symbol;
 declare const _instance: unique symbol;
 declare const _destroyed: unique symbol;
-export declare type PropertyAccessInstance = Bindable & {
+export type PropertyAccessInstance = Bindable & {
     [ACCESS_IN_INSTANCE_KEY]?: PropertyAccess;
 };
-export declare type GroupId = number | string;
+export type GroupId = number | string;
 export interface WatchState {
     name: PropertyName;
     value: any;
@@ -35,5 +35,5 @@ export declare class PropertyAccess {
     watch(propertyName: PropertyName, watchListener: WatchListener): WatchHandle;
     destroy(): void;
 }
-declare type WatchListener = (state: WatchState, ...args: any[]) => void;
+type WatchListener = (state: WatchState, ...args: any[]) => void;
 export {};

package/apprt-binding/Transformers.d.ts

@@ -5,7 +5,7 @@ import type { ConvertFunction } from "./Binding";
 /**
  * Transforms a value into another value.
  */
-export declare type Transformer = ConvertFunction;
+export type Transformer = ConvertFunction;
 /**
  * A transformer that also supports an `else` function that can be used
  * when the transformer would otherwise skip a value (e.g. if {@link isDefined} is being used).

package/apprt-binding/Watchable.d.ts

@@ -7,7 +7,7 @@ export interface WatchEvent {
  * Note: the event object might not be present if the watchable did not wrap the watch method, i.e.
  * if the Bindable already had a watch method.
  */
-export declare type InternalWatchCallback = (event?: WatchEvent) => void;
+export type InternalWatchCallback = (event?: WatchEvent) => void;
 /**
  * A watchable wraps a Bindable instance and provides the complete interface.
  * Optional methods that are not present on the original Bindable implementation will be

package/apprt-binding/shared.d.ts

@@ -1,2 +1,2 @@
-export declare type TaskFunction<Args extends any[]> = (...args: Args) => void;
+export type TaskFunction<Args extends any[]> = (...args: Args) => void;
 export declare function triggerMicroTasks<Args extends any[]>(fns?: TaskFunction<Args>[], ...args: Args): void;

package/apprt-core/CancelablePromise.d.ts

@@ -6,7 +6,7 @@ import ExtendedPromise from "./Promise";
  * @param reject callback to reject the promise with an error
  * @param onCancelled accepts a cleanup function to invoke when the promise is cancelled
  */
-export declare type CancelablePromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancelled: (cleanup: () => void) => void) => void;
+export type CancelablePromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancelled: (cleanup: () => void) => void) => void;
 /**
  * Promise class which provides a 'cancel' method.
  * Read more about [Promises](./PROMISES.md).

package/apprt-core/Events.d.ts

@@ -1,12 +1,12 @@
 import type { Equal } from "./Types";
 /** Valid event names for the given events specifier. */
-export declare type EventNames<Events> = keyof Events & string;
-declare type Params<T> = Equal<T, any> extends true ? [] | [value: unknown] : Equal<T, void> extends true ? [] : [value: T];
+export type EventNames<Events> = keyof Events & string;
+type Params<T> = Equal<T, any> extends true ? [] | [value: unknown] : Equal<T, void> extends true ? [] : [value: T];
 /**
  * Type of an event listener.
  * @typeParam T the type of the event value. If `T` is `void`, no value will be available.
  */
-export declare type EventCallback<T> = (...values: Params<T>) => void;
+export type EventCallback<T> = (...values: Params<T>) => void;
 /** A handle that allows de-registration from events. */
 export interface EventHandle {
     /**
@@ -85,7 +85,7 @@ export interface Evented<Events> {
  * This is useful if clients of a class should not be able to invoke the `emit()` function
  * themselves.
  */
-export declare type EventSource<Events> = Pick<Evented<Events>, "on">;
+export type EventSource<Events> = Pick<Evented<Events>, "on">;
 interface Constructor<T extends {}, Args extends any[]> {
     new (...args: Args): T;
 }

package/apprt-core/InjectedReference.d.ts

@@ -3,5 +3,5 @@
  *
  * @typeParam T the type of the injected reference
  */
-export declare type InjectedReference<T> = T | undefined;
+export type InjectedReference<T> = T | undefined;
 export declare const _null: null;

package/apprt-core/Logger.d.ts

@@ -7,7 +7,7 @@
  * * If ERROR is enabled for a logger, then the messages on level ERROR are logged.
  * * If OFF is enabled for a logger, then nothing is logged.
  */
-export declare type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR" | "OFF";
+export type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR" | "OFF";
 /**
  * A logger interface.
  * It is inspired from the interface and behavior of the
@@ -209,7 +209,7 @@ export declare function getLogConfig(): [string, LogLevel][];
 /**
  * Type of a effective output method.
  */
-export declare type WriterMethod = (msg: string, ...params: any[]) => void;
+export type WriterMethod = (msg: string, ...params: any[]) => void;
 /**
  * The effective writer of log messages.
  * The default Writer implementation is the console.

package/apprt-core/Mutable.d.ts

@@ -2,8 +2,8 @@ declare const _mutableMembers: unique symbol;
 interface MembersTag<Members> {
     [_mutableMembers]: Members;
 }
-declare type PropertyKey = string | symbol;
-declare type SimpleValueSpec = null | undefined | boolean | number | PropertyKey | bigint | any[];
+type PropertyKey = string | symbol;
+type SimpleValueSpec = null | undefined | boolean | number | PropertyKey | bigint | any[];
 interface ComplexValueSpec<T> {
     value?: T;
     type?: PropType<T>;
@@ -16,35 +16,35 @@ interface ComplexValueSpec<T> {
     cast?(value: unknown): T;
     clone?(value: T): T;
 }
-declare type ValueSpec = SimpleValueSpec | ComplexValueSpec<any>;
-declare type MethodSpec = (...args: any[]) => any;
-declare type SpecialNames = "$inherit" | "$watch" | "$construct";
-declare type WatchAction<T> = (value: T) => void;
-declare type WatchItem<T> = WatchAction<T> | {
+type ValueSpec = SimpleValueSpec | ComplexValueSpec<any>;
+type MethodSpec = (...args: any[]) => any;
+type SpecialNames = "$inherit" | "$watch" | "$construct";
+type WatchAction<T> = (value: T, evt: WatchEvent<any, T>) => void;
+type WatchItem<T> = WatchAction<T> | {
     triggerOnInit?: boolean;
     depends?: PropertyKey[];
     do: WatchAction<T>;
 };
-export declare type MutableDefinition<T> = {
-    $watch?: Record<PropertyKey, WatchItem<any>>;
+export type MutableDefinition<T> = {
+    $watch?: Record<PropertyKey, WatchItem<any> & ThisType<Mutable<BuildMutableMembers<MutableDefinition<T>>>>>;
     $construct?(options?: any): void;
 } & {
     [P in keyof Exclude<T, SpecialNames>]: ValueSpec | MethodSpec | any;
 };
-declare type IsEmptyObject<T> = T extends {} ? ({} extends T ? true : false) : false;
-declare type ResolveSpecType<Spec> = Spec extends {
+type IsEmptyObject<T> = T extends {} ? ({} extends T ? true : false) : false;
+type ResolveSpecType<Spec> = Spec extends {
     type: PropType<infer T>;
 } ? T : Spec extends {
     value: infer V;
 } ? V : Spec extends ComplexValueSpec<infer V> ? V : never;
-declare type ResolveSpecRequired<Spec, ResolvedType> = Spec extends {
+type ResolveSpecRequired<Spec, ResolvedType> = Spec extends {
     required: true;
 } ? NonNullable<ResolvedType> : ResolvedType | undefined;
-declare type InferTypeFromComplexValueSpec<Spec> = ResolveSpecRequired<Spec, ResolveSpecType<Spec>>;
-declare type MapSpecToProperty<Spec, Original = Spec> = Spec extends SimpleValueSpec ? Original | undefined : IsEmptyObject<Spec> extends true ? Spec | undefined : Spec extends ComplexValueSpec<any> ? InferTypeFromComplexValueSpec<Spec> : never;
-declare type MapSpecToClassMember<Spec, Original = Spec> = Spec extends ValueSpec ? MapSpecToProperty<Original> : Spec extends MethodSpec ? Spec : never;
-declare type ExcludeSpecialPropertiesAndInvalidSpecs<Name, Spec> = Exclude<Name, SpecialNames> extends never ? never : MapSpecToClassMember<Spec> extends never ? never : Name;
-declare type BuildMutableMembers<Specs> = {
+type InferTypeFromComplexValueSpec<Spec> = ResolveSpecRequired<Spec, ResolveSpecType<Spec>>;
+type MapSpecToProperty<Spec, Original = Spec> = Spec extends SimpleValueSpec ? Original | undefined : IsEmptyObject<Spec> extends true ? Spec | undefined : Spec extends ComplexValueSpec<any> ? InferTypeFromComplexValueSpec<Spec> : never;
+type MapSpecToClassMember<Spec, Original = Spec> = Spec extends ValueSpec ? MapSpecToProperty<Original> : Spec extends MethodSpec ? Spec : never;
+type ExcludeSpecialPropertiesAndInvalidSpecs<Name, Spec> = Exclude<Name, SpecialNames> extends never ? never : MapSpecToClassMember<Spec> extends never ? never : Name;
+type BuildMutableMembers<Specs> = {
     [P in keyof Specs as ExcludeSpecialPropertiesAndInvalidSpecs<P, Specs[P]>]: MapSpecToClassMember<Specs[P]>;
 };
 /** Common methods and properties present on all mutable instances. */
@@ -102,7 +102,7 @@ interface MutableBase<Members> extends MembersTag<Members> {
  * Represents the type of mutable instances built from some definition.
  * All properties and methods listed in the original definition are mapped to class members.
  */
-export declare type Mutable<Members> = MutableBase<Members> & Members;
+export type Mutable<Members> = MutableBase<Members> & Members;
 /**
  * Event that is emitted when a property value changes.
  */
@@ -115,17 +115,17 @@ export interface WatchEvent<Name = PropertyKey, T = unknown> {
     value: T;
 }
 /** Event handler function type for property changes. */
-export declare type WatchCallback<Name, T> = (event: WatchEvent<Name, T>) => void;
+export type WatchCallback<Name, T> = (event: WatchEvent<Name, T>) => void;
 /** Handle that allows disconnecting from a previous `watch()` call. */
 export interface WatchHandle {
     /** Stops watching for property changes. */
     remove(): void;
 }
-declare type RemoveFunction<T> = T extends (...args: any[]) => any ? never : true;
-declare type RemoveFunctions<T> = {
+type RemoveFunction<T> = T extends (...args: any[]) => any ? never : true;
+type RemoveFunctions<T> = {
     [P in keyof T as RemoveFunction<T[P]> extends never ? never : P]: T[P];
 };
-export declare type PropType<T> = {
+export type PropType<T> = {
     (): T;
 } | {
     new (...args: never[]): T & object;
@@ -135,13 +135,13 @@ export declare type PropType<T> = {
 /**
  * This type lists all valid properties of the given mutable, including their types.
  */
-export declare type Properties<M extends Mutable<any>> = M extends MembersTag<infer V> ? RemoveFunctions<V> : {};
+export type Properties<M extends Mutable<any>> = M extends MembersTag<infer V> ? RemoveFunctions<V> : {};
 /**
  * This type is a union listing all valid property identifiers for the given mutable.
  */
-export declare type PropertyName<M extends Mutable<any>> = Extract<keyof Properties<M>, PropertyKey>;
+export type PropertyName<M extends Mutable<any>> = Extract<keyof Properties<M>, PropertyKey>;
 /** Excludes symbol properties from the list of property names (they are not watchable via '*') */
-declare type PublicPropertyName<M extends Mutable<any>> = Exclude<PropertyName<M>, symbol>;
+type PublicPropertyName<M extends Mutable<any>> = Exclude<PropertyName<M>, symbol>;
 /**
  * Represents the type of a mutable class created from a definition.
  * Instances of this type are created by calling the `declare()` function.

package/apprt-core/Observers.d.ts

@@ -5,7 +5,7 @@ export interface HandleMethods {
     unregister?(): void;
     unsubscribe?(): void;
 }
-declare type RequiredKey<T, K extends keyof T> = Required<Pick<T, K>> & T;
+type RequiredKey<T, K extends keyof T> = Required<Pick<T, K>> & T;
 /**
  * Type of supported cleanup handles.
  *
@@ -16,9 +16,9 @@ declare type RequiredKey<T, K extends keyof T> = Required<Pick<T, K>> & T;
  *  - unregister()
  *  - unsubscribe()
  */
-export declare type Handle = RequiredKey<HandleMethods, "destroy"> | RequiredKey<HandleMethods, "dispose"> | RequiredKey<HandleMethods, "remove"> | RequiredKey<HandleMethods, "unregister"> | RequiredKey<HandleMethods, "unsubscribe"> | null | undefined;
+export type Handle = RequiredKey<HandleMethods, "destroy"> | RequiredKey<HandleMethods, "dispose"> | RequiredKey<HandleMethods, "remove"> | RequiredKey<HandleMethods, "unregister"> | RequiredKey<HandleMethods, "unsubscribe"> | null | undefined;
 /** Type of the rebind callback supported by {@link Observers} and {@link ObserverGroup}. */
-export declare type RebindCallback = (self: Observers | ObserverGroup, ...args: unknown[]) => void;
+export type RebindCallback = (self: Observers | ObserverGroup, ...args: unknown[]) => void;
 /**
  * ObserverGroups contain a series of handles.
  */

package/apprt-core/Promise.d.ts

@@ -12,7 +12,7 @@ export interface StateQueryable {
     /** Returns true if the promise was cancelled before it was able to complete. */
     isCancelled(): boolean;
 }
-declare type State = "pending" | "fulfilled" | "rejected" | "cancelled";
+type State = "pending" | "fulfilled" | "rejected" | "cancelled";
 declare const PROMISE: unique symbol;
 declare const STATE: unique symbol;
 declare const PRIVATE_CONSTUCTOR_TAG: unique symbol;