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

package/apprt-fetch/index.d.ts

@@ -0,0 +1,470 @@
+/**
+ * Provides a wrapper around the browsers `fetch` API.
+ *
+ * @example Fetch a json file
+ * ```js
+ * import { apprtFetch, ContentType} from "apprt-fetch";
+ *
+ * // execute a get request
+ * const response = await apprtFetch("https://httpbin.org/json", {
+ *     // query parameters f=json
+ *     query: { f: "json" },
+ *     headers: {
+ *        // accept only json responses
+ *        "Accept": ContentType.JSON
+ *     },
+ *     // throw error if response status is not 2XX
+ *     checkStatus: true
+ * });
+ *
+ * // Parse the response body as json.
+ * const data = await response.json();
+ * ```
+ * @example Fetch a json file with apprtFetchJson
+ * ```js
+ * import { apprtFetchJson } from "apprt-fetch";
+ *
+ * // execute a get request
+ * const data = await apprtFetchJson("https://httpbin.org/json", {
+ *     // query parameters f=json
+ *     query: { f: "json" }
+ * });
+ * ```
+ *
+ * @example POST x-www-form-urlencoded content
+ * ```js
+ * import { apprtFetch, ContentType } from "apprt-fetch";
+ *
+ * // execute a POST request
+ * const response = await apprtFetch("https://httpbin.org/post", {
+ *     // declare that POST should be used
+ *     method: "POST",
+ *     // throw error if response status is not 2XX
+ *     checkStatus: true,
+ *     headers: {
+ *        // accept only json responses
+ *        "Accept": ContentType.JSON
+ *     },
+ *     // Specify the POST-Body with URLSearchParams.
+ *     // The "Content-Type" Header is automatically set to
+ *     // "application/x-www-form-urlencoded;charset=UTF-8"
+ *     body: new URLSearchParams({ f: "json" })
+ * });
+ *
+ * // Parse the response body as json.
+ * const data = await response.json();
+ * ```
+ *
+ * @example POST x-www-form-urlencoded content with flag encodeQueryAsBody
+ * ```js
+ * import { apprtFetch, ContentType } from "apprt-fetch";
+ *
+ * // execute a POST request
+ * const response = await apprtFetch("https://httpbin.org/post", {
+ *     // declare that POST should be used
+ *     method: "POST",
+ *     // throw error if response status is not 2XX
+ *     checkStatus: true,
+ *
+ *     headers: {
+ *        // accept only json responses
+ *        "Accept": ContentType.JSON
+ *     },
+ *
+ *     // normally this would stay url parameters ?f=json
+ *     query: { f: "json" }
+ *
+ *     // but this flags converts the query to the body
+ *     encodeQueryAsBody: true
+ * });
+ *
+ * // Parse the response body as json.
+ * const data = await response.json();
+ * ```
+ * @example POST application/json content
+ * ```js
+ * import { apprtFetch, ContentType } from "apprt-fetch";
+ *
+ * // execute a POST request
+ * const response = await apprtFetch("https://httpbin.org/post", {
+ *     // declare that POST should be used
+ *     method: "POST",
+ *     // throw error if response status is not 2XX
+ *     checkStatus: true,
+ *     headers: {
+ *        // Set the Content-Type of the body
+ *        "Content-Type": ContentType.JSON_UTF8,
+ *        // accept only json responses
+ *        "Accept": ContentType.JSON
+ *     },
+ *     // Specify the POST-Body
+ *     body: JSON.stringify({ id: "test" })
+ * });
+ *
+ * // Parse the response body as json.
+ * const data = await response.json();
+ * ```
+ * @module
+ */
+import type { DeepReadonly } from "apprt-core/Types";
+export { ContentType } from "./ContentType";
+/**
+ * Specifies a proxy rule.
+ * Requests targeting the `origin` server of a proxy rule will use the configured proxy server
+ * to fetch the resource.
+ */
+export interface ProxyRule {
+    /**
+     * An origin to match against request URLs.
+     * URLs matching this origin pattern will use the configured `proxyUrl` (if present)
+     * or the default proxy URL.
+     *
+     * Origins must contain protocol, a hostname and (optionally) a port.
+     * For example, `https://subdomain.arcgis.com` is a valid origin.
+     */
+    origin: string;
+    /**
+     * URL to a server endpoint that can act as proxy.
+     * If this URL is not specified, a default proxy will be used.
+     */
+    proxyUrl?: string;
+}
+/**
+ * Represents a trusted server configuration.
+ *
+ * Trusted servers automatically receive user credentials (e.g. cookies) by default,
+ * so there is no need to specify security settings on individual requests.
+ */
+export interface TrustedServer {
+    /**
+     * An origin to match against request URLs.
+     *
+     * Origins must contain protocol, a hostname and (optionally) a port.
+     * For example, `https://subdomain.arcgis.com` is a valid origin.
+     */
+    origin: string;
+}
+/** Properties that should not be changed from an interceptor. */
+declare type ReadonlyInitProperties = "query" | "timeoutMillis" | "checkStatus" | "signal" | "context";
+/**
+ * Options passed into interceptors.
+ * Most options can be modified to customize the request that is about to be sent.
+ */
+export declare type InterceptorOptions = Omit<ApprtRequestInit, ReadonlyInitProperties> & Readonly<Pick<ApprtRequestInit, ReadonlyInitProperties>> & {
+    method: string;
+    headers: Headers;
+    query: undefined;
+};
+/**
+ * Arguments available to 'before' interceptors.
+ */
+export interface BeforeInterceptorData {
+    /**
+     * The current request's target URL, including query parameters.
+     * Can be modified to redirect the request to a different location.
+     */
+    target: URL;
+    /** Other request options (e.g. headers). */
+    readonly options: InterceptorOptions;
+    /**
+     * The context object is a per-request object that is passed to all
+     * interceptors.
+     * It can be used to keep interceptor state for a request.
+     *
+     * Use a sensible namespace string or a symbol to store state
+     * to avoid naming collisions.
+     */
+    readonly context: Record<string | symbol, unknown>;
+    /** AbortSignal for cancellation support. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Arguments available to 'after' interceptors.
+ */
+export interface AfterInterceptorData {
+    /**
+     * The request's target URL, including query parameters.
+     * This is the original URL, before the request was potentially re-routed over a proxy server.
+     */
+    readonly target: URL;
+    /** The options used when making the request. */
+    readonly options: InterceptorOptions;
+    /** The request that was sent to the server. */
+    readonly request: Request;
+    /** The response returned by the server. */
+    readonly response: Response;
+    /**
+     * The context object is a per-request object that is passed to all
+     * interceptors.
+     * It can be used to keep interceptor state for a request.
+     *
+     * Use a sensible namespace string or a symbol to store state
+     * to avoid naming collisions.
+     */
+    readonly context: Record<string | symbol, unknown>;
+    /** AbortSignal for cancellation support. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * An interceptor can intercept and manipulate requests (and their responses) before
+ * or after they have been sent to the server.
+ */
+export interface Interceptor {
+    /**
+     * This method will be invoked before a request is sent to the server.
+     * The implementor may alter the input arguments (e.g. query parameters in {@link BeforeInterceptorData.target}).
+     */
+    before?(data: BeforeInterceptorData): void | undefined | Promise<void | undefined>;
+    /**
+     * This method will be invoked after the server responded to a request.
+     * The implementor may substitute a custom response instead.
+     */
+    after?(data: AfterInterceptorData): void | Response | Promise<void | Response>;
+}
+/**
+ * A handle allows the holder to destroy or remove a resource.
+ */
+export interface Handle {
+    /**
+     * Performs a cleanup action.
+     */
+    remove(): void;
+}
+/**
+ * Global configuration of this bundle.
+ */
+export interface Config {
+    /**
+     * Maximum length of an url before a GET request is switched to POST.
+     * GET requests altered in this way will have their query parameters
+     * placed into the new POST request's body (as content-type application/x-www-form-urlencoded).
+     *
+     * Switching to POST requests can be disabled by setting this property to a value `<= 0`.
+     */
+    maxUrlLength: number;
+    /**
+     * Default time in milliseconds after which fetch aborts with a timeout.
+     */
+    timeoutMillis: number;
+    /**
+     * The default proxy to use.
+     */
+    defaultProxy: string | undefined;
+    /**
+     * If this is `true`, proxy support will be completely disabled.
+     */
+    disableProxySupport: boolean;
+    /**
+     * Usage rules for proxied requests.
+     *
+     * When a proxy rule matches a request URL, the proxy will be
+     * chosen to perform the request instead.
+     */
+    readonly proxyRules: DeepReadonly<ProxyRule>[];
+    /**
+     * Usages rules for trusted servers.
+     *
+     * apprt-fetch will automatically send credentials to these servers.
+     */
+    readonly trustedServers: DeepReadonly<TrustedServer>[];
+    /**
+     * Globally registered interceptors.
+     */
+    readonly interceptors: DeepReadonly<Interceptor>[];
+    /**
+     * Adds a new proxy rule to the configuration.
+     * Requests that match the rule's `origin` will use the specified `proxyUrl`.
+     *
+     * Note: there can only be one proxy rule for an origin.
+     */
+    addProxyRule(rule: ProxyRule): void;
+    /**
+     * Removes a proxy rule from the configuration.
+     */
+    removeProxyRule(rule: Pick<ProxyRule, "origin">): void;
+    /**
+     * Adds a new trusted server rule to the configuration.
+     * Requests that match the rule will send credentials automatically,
+     * without the need to declare it in individual requests.
+     *
+     * Note: there can only be one trusted server rule for an origin.
+     */
+    addTrustedServer(server: TrustedServer): void;
+    /**
+     * Removes a trusted server rule from the configuration.
+     */
+    removeTrustedServer(server: Pick<TrustedServer, "origin">): void;
+    /**
+     * Registers a global interceptor.
+     * Use the handle returned by this method to deregister the interceptor
+     * when it is no longer needed.
+     */
+    registerInterceptor(interceptor: Interceptor): Handle;
+}
+/** Used to control the proxy mode for requests. */
+export declare type ProxyMode = "force-on" | "force-off" | "default";
+/**
+ * Request options supported by apprt-request.
+ * This is an extension of the Browser's native fetch options.
+ *
+ * See also the init parameter of [apprt-fetch](https://developer.mozilla.org/en-US/docs/Web/API/fetch)
+ * for a list of all options provided by the browser.
+ */
+export interface ApprtRequestInit extends RequestInit {
+    /**
+     * Time in milliseconds after which the fetch aborts with a timeout.
+     * Defaults to the timeout settings on the global configuration object: {@link config}.
+     */
+    timeoutMillis?: number;
+    /**
+     * Ensures that the target resource is fresh from the server.
+     * This is a shorthand for the fetch option `cache: "no-store"`.
+     */
+    preventCache?: boolean;
+    /**
+     * If true, throws an error if the response is not `ok`, i.e. if
+     * the response status code is not between 200 and 299.
+     *
+     * Default: false.
+     */
+    checkStatus?: boolean;
+    /**
+     * By default, requests will use a proxy only if a proxy rule matches.
+     *
+     * If `"force-on"` is configured, the request will always use a proxy server,
+     * falling back to the default proxy if no proxy rule matches.
+     * An error will be thrown if no default proxy is configured in this case.
+     *
+     * If `"force-off"` is used, no proxy server will be used, even if a proxy rule would match.
+     */
+    proxyMode?: ProxyMode;
+    /**
+     * Convenience option to add additional query arguments to the request.
+     * The transport of the given value depends on the value of `queryTransport`.
+     * By default, query arguments passed here will be appended to the query part of the request URL.
+     */
+    query?: string | URLSearchParams | Record<string, any>;
+    /**
+     * Configures the way the `query` value is transported to the server.
+     *
+     * - Use the value `"url"` (the default) to append the query to the request url.
+     * - Use `"form"` instead to set the request body to `query` (encoded as `application/x-www-form-urlencoded`).
+     *   No other request body should be specified in this case.
+     *
+     * If `query` is a string, then it should already be URL encoded.
+     * If `query` is an instance of URLSearchParams, all params will simply be copied.
+     * If `query` is a plain object, all properties will be serialized by calling `objectToQuery()` from
+     * `apprt-core/url-utils`.
+     *
+     * Default: `"url"`.
+     */
+    queryTransport?: "url" | "form";
+    /**
+     * Arbitrary settings that can be read by interceptors.
+     */
+    context?: Record<string | symbol, unknown>;
+}
+/**
+ * Represents a request location.
+ * Can be used as an argument to this bundle's `fetch()` function.
+ */
+export declare type ApprtRequestTarget = string | URL;
+/**
+ * Get global configuration options for the apprt-fetch bundle.
+ */
+export declare function getConfig(): Config;
+/**
+ * Fetches the specified resource.
+ * Works like the browser's `fetch()` function, but supports a few extensions.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/fetch
+ *
+ * @example
+ *
+ * Basic usage:
+ *
+ * ```js
+ * import { apprtFetch } from "apprt-fetch";
+ * const response = await apprtFetch("https://httpbin.org/get");
+ * if (!response.ok) {
+ *     throw new Error(`Request failed with status: ${response.status}`);
+ * }
+ * const data = await response.json();
+ * ```
+ *
+ * See the bundle `README` for more advanced use cases.
+ */
+export declare function apprtFetch(target: ApprtRequestTarget, init?: ApprtRequestInit): Promise<Response>;
+/**
+ * Fetches the specified resource and expects a JSON encoded response.
+ * It is a small helper to make fetching of json data more simple.
+ * It has the `checkStatus` flag enabled by default and sets the Accept Header to 'application/json'.
+ *
+ * @example
+ *
+ * Basic usage:
+ *
+ * ```js
+ * import { apprtFetchJson } from "apprt-fetch";
+ * const jsonData = await apprtFetchJson("https://httpbin.org/get");
+ * // do something with the json data
+ * ```
+ */
+export declare function apprtFetchJson<T = unknown>(target: ApprtRequestTarget, init?: ApprtRequestInit): Promise<T>;
+/**
+ * Options for the {@link getProxiedUrl} function.
+ */
+export interface ProxyUrlOptions {
+    /** Force usage of default proxy if no proxy rule matches the given target URL. */
+    force?: boolean;
+    /** Return undefined if no proxy server is being used. */
+    check?: boolean;
+}
+/**
+ * Returns an URL to fetch the resource at `target` that uses a proxy server if necessary.
+ *
+ * By default, a proxy server will only be used if there is a matching proxy server rule.
+ * If `force` is `true`, the default proxy (if configured) will always be used if no other rule matches.
+ *
+ * The default configuration always returns a valid URL, even if no proxy server will be used.
+ * If `check` is `true`, the function will return `undefined` instead to signal that there was no matching rule.
+ */
+export declare function getProxiedUrl(target: ApprtRequestTarget): URL;
+export declare function getProxiedUrl(target: ApprtRequestTarget, options?: ProxyUrlOptions & {
+    check?: false;
+}): URL;
+export declare function getProxiedUrl(target: ApprtRequestTarget, options?: ProxyUrlOptions): URL | undefined;
+/**
+ * Represents a custom implementation of the apprt-fetch library.
+ * Used for testing.
+ */
+export interface CustomFetch {
+    /** A separate instance of the configuration (non-global). */
+    readonly config: Config;
+    /** Call this method to clean up any state associated with this instance. */
+    destroy(): void;
+    /** Fetches the given target and returns the response. */
+    fetch(target: ApprtRequestTarget, init?: ApprtRequestInit): Promise<Response>;
+    /** Fetches JSON data from the given target and returns the response data. */
+    fetchJson<T = unknown>(target: ApprtRequestTarget, init?: ApprtRequestInit): Promise<T>;
+}
+/** Function signature required by `createCustomFetch`. */
+export declare type BasicFetchFunction = (request: Request) => Promise<Response>;
+/**
+ * Creates a custom fetch instance with a user defined 'backend' function.
+ * This is useful for testing if you do not want your requests to against an actual backend service.
+ *
+ * The implementation returned by this function will implement all the usual features of apprt-fetch
+ * but will call the provided `impl` function instead of using the browser's `fetch` API
+ * to retrieve a response.
+ */
+export declare function createCustomFetch(options: {
+    impl: BasicFetchFunction;
+}): CustomFetch;
+/**
+ * Returns an implementation of `CustomFetch` that uses the global fetch function(s).
+ * This is convenient for writing testable code: a class can accept a `CustomFetch` instance
+ * for testing and for production.
+ */
+export declare function getGlobalImpl(): CustomFetch;
+export { apprtFetch as fetch };

package/apprt-fetch/origin.d.ts

@@ -0,0 +1,26 @@
+export declare type Protocol = "http:" | "https:";
+export declare class OriginPattern {
+    readonly protocol: Protocol | undefined;
+    readonly hostname: string;
+    readonly port: string | undefined;
+    readonly path: string;
+    /**
+     * Attempts to parse a pattern from the given string.
+     * Throws an error if the pattern is invalid.
+     */
+    static fromString(pattern: string): OriginPattern;
+    private constructor();
+    /**
+     * Returns true if `other` is equivalent to `this`, false otherwise.
+     */
+    equalTo(other: OriginPattern): boolean;
+    /**
+     * Returns true if the given `url` matches this pattern,
+     * false otherwise.
+     */
+    matches(url: URL): boolean;
+    /**
+     * Serialized this pattern to a normalized string representation.
+     */
+    toString(): string;
+}

package/apprt-fetch/package.json

@@ -0,0 +1,5 @@
+{
+    "name": "apprt-fetch",
+    "dependencies": {},
+    "types": "./index.d.ts"
+}

package/apprt-request/impl/ProxyRule.d.ts

@@ -4,7 +4,7 @@ export interface ProxyRule {
 }
 export declare function ProxyRule(options: {
     origin: string;
-    proxyUrl: string;
+    proxyUrl?: string;
 }): ProxyRule;
 export default ProxyRule;
 export declare function applyProxyUrl(proxyUrl: string, url: string): string;

package/apprt-streams/Stream.d.ts

@@ -187,6 +187,13 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * @param iterables the iterables to zip
      */
     static zipLongest<Ts extends Iterable<any>[] | [Iterable<any>]>(...iterables: Ts): Stream<ZipLongestValue<Ts>>;
+    /**
+     * Generates [index, value] tuples where value is from the original iterable
+     * and index is the index of the current value.
+     *
+     * @see {@link Stream.enumerate}
+     */
+    enumerate(): Stream<[index: number, value: T]>;
     /**
      * Returns a stream that filters the input by `predicate`. Only items for which `predicate(item)`
      * returns true will be produced by the stream.
@@ -418,7 +425,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
     groupAdjacent(predicate: (left: T, right: T) => boolean): Stream<T[]>;
     /**
      * Returns a stream that has all its elements sorted according to the given `compareFunc`.
-     * The comparison function is optional, the Array sort behaviour will be used by default when
+     * The comparison function is optional, the Array sort behavior will be used by default when
      * the function is omitted. The function must behave as expected by the `Array.sort()` method.
      *
      * See also: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
@@ -538,7 +545,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
     reduce<U>(reduceFunc: (currentValue: U, item: T, index: number) => U, initial: U): U;
     /**
      * Joins all elements of this stream together into a string.
-     * Individual elements will converted to string (via `String(elements)`)
+     * Individual elements will be converted to string (via `String(elements)`)
      * and separated by `separator`.
      *
      * @param separator The separator to use between two elements. Defaults to `","`.
@@ -550,6 +557,48 @@ export declare abstract class Stream<T> implements Iterable<T> {
      * NOTE: this will iterate over the entire stream!
      */
     count(): number;
+    /**
+     * Returns `true` if there is at least one element in this stream, `false` otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the largest stream item according to the given `compareFunc`.
+     * If the multiple candidates for the largest element compare equal to each other,
+     * the first of those items (according to the stream order) will be returned.
+     *
+     * @param compareFunc
+     *  Given two elements `left` and `right`, returns `< 0` if `left < right`, `> 0` if `right > left`
+     *  and `0` otherwise.
+     *  When not specified, elements are compared using standard `<` and `>` (which might be useless,
+     *  e.g. when keys are objects or arrays).
+     *
+     * @returns the largest item or `undefined` if the stream is empty.
+     */
+    max(compareFunc?: (left: T, right: T) => number): T | undefined;
+    /**
+     * Like {@link max}, but returns the smallest item instead.
+     */
+    min(compareFunc?: (left: T, right: T) => number): T | undefined;
+    /**
+     * Like `max()`, but compares keys derived from the stream's items instead of the items themselves.
+     * The item with the largest key will be returned (or undefined if the stream is empty).
+     *
+     * @param keyFunc
+     *  Given an item, returns a sort key for comparison during sorting.
+     *  This function should be fast, because it will be invoked at least once for every element.
+     *
+     * @param compareFunc
+     *  Given two keys derived by `keyFunc`, returns `< 0` if `left < right`, `> 0` if `right > left` and `0` otherwise.
+     *  When not specified, keys are compared using standard `<` and `>` (which might be useless,
+     *  e.g. when keys are objects or arrays).
+     *
+     * @returns the largest item or `undefined` if the stream is empty.
+     */
+    maxBy<U>(keyFunc: (value: T) => U, compareFunc?: (left: U, right: U) => number): T | undefined;
+    /**
+     * Like {@link maxBy}, but returns the item with the smallest key instead.
+     */
+    minBy<U>(keyFunc: (value: T) => U, compareFunc?: (left: U, right: U) => number): T | undefined;
     /**
      * Gathers all elements of this stream into an array.
      *
@@ -573,7 +622,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
      *      .toObject(); // { a: "a!", b: "b!", c: "c!"}
      * ```
      */
-    toObject(this: T extends [PropertyKey, any] ? this : never): T extends [infer K, infer V] ? (K extends PropertyKey ? Record<K, V> : never) : never;
+    toObject(this: T extends [PropertyKey, any] ? this : never): T extends [infer K, infer V] ? [K] extends [PropertyKey] ? Record<K, V> : never : never;
     /**
      * Gathers all elements of this stream into a set.
      *
@@ -610,7 +659,7 @@ export declare abstract class Stream<T> implements Iterable<T> {
      *
      * ```js
      * for (const value of Stream.integers(5)) {
-     *     console.log(value);
+     *     console.info(value);
      * }
      * ```
      */

package/apprt-streams/StreamPiece.d.ts

@@ -6,9 +6,6 @@ export declare const EMPTY: StreamPiece<any>;
 export declare function from<T>(input: Iterable<T>): StreamPiece<T> & {
     _input: Iterable<T>;
 };
-export declare function singleton<T>(item: T): StreamPiece<T> & {
-    _item: T;
-};
 export declare function keys<K extends string, T>(input: Record<K, T>): StreamPiece<K> & {
     _input: Record<K, T>;
 };

package/apprt-tokens/TokenRequestInterceptor.d.ts

@@ -0,0 +1,10 @@
+import type { TokenService } from "./api";
+import type { InjectedReference } from "apprt-core/InjectedReference";
+import { BeforeInterceptorData, Interceptor } from "apprt-fetch";
+export declare class TokenRequestInterceptor implements Interceptor {
+    #private;
+    set tokenService(service: InjectedReference<TokenService>);
+    activate(): void;
+    deactivate(): void;
+    before?({ target, context, options, signal }: BeforeInterceptorData): Promise<void>;
+}

package/apprt-tokens/TokenServiceImpl.d.ts

@@ -1,4 +1,5 @@
 import type { TokenService, TokenLookupResult, AbortOptions } from "./api";
+import { apprtFetchJson } from "apprt-fetch";
 /**
  * The default token service implementation communicates with the `/account/tokens` endpoint to lookup matching tokens.
  * This service is only active if the security.mode is OAUTH.
@@ -12,6 +13,9 @@ import type { TokenService, TokenLookupResult, AbortOptions } from "./api";
  */
 export declare class TokenServiceImpl implements TokenService {
     #private;
+    constructor(options?: {
+        fetchJson?: typeof apprtFetchJson;
+    });
     set _properties(value: ConfigProperties);
     findDirectAvailableTokenFor(target: string): TokenLookupResult | undefined;
     findTokenFor(target: string, { signal }?: AbortOptions): Promise<TokenLookupResult | undefined>;

package/apprt-tokens/module.d.ts

@@ -1,2 +1,3 @@
 export { TokenServiceImpl as Config } from "./TokenServiceImpl";
 export { TokenRequestPreProcessor } from "./TokenRequestPreProcessor";
+export { TokenRequestInterceptor } from "./TokenRequestInterceptor";

package/appsoverview/DataViewController.d.ts

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

package/appsoverview/module.d.ts

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

package/appsstore/AppStore.d.ts

@@ -21,4 +21,4 @@ export default class AppStore extends RQLStore<any, any> {
         })[];
     };
 }
-import { RQLStore } from "../../search/store-api/rest/RQLStore";
+import { RQLStore } from "store-api/rest/RQLStore";

package/appsstore/AppStoreService.d.ts

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

package/appsstore/TemplateStore.d.ts

@@ -21,4 +21,4 @@ export default class TemplateStore extends RQLStore<any, any> {
         })[];
     };
 }
-import { RQLStore } from "../../search/store-api/rest/RQLStore";
+import { RQLStore } from "store-api/rest/RQLStore";