@backstage/backend-plugin-api 0.2.0 → 0.3.0-next.1

package/dist/index.alpha.d.ts

@@ -4,18 +4,15 @@
  * @packageDocumentation
  */
 
+/// <reference types="node" />
+
 import { Config } from '@backstage/config';
 import { Handler } from 'express';
-import { Logger } from 'winston';
-import { PermissionAuthorizer } from '@backstage/plugin-permission-common';
+import { JsonValue } from '@backstage/types';
+import { Knex } from 'knex';
 import { PermissionEvaluator } from '@backstage/plugin-permission-common';
-import { PluginCacheManager } from '@backstage/backend-common';
-import { PluginDatabaseManager } from '@backstage/backend-common';
-import { PluginEndpointDiscovery } from '@backstage/backend-common';
 import { PluginTaskScheduler } from '@backstage/backend-tasks';
-import { TokenManager } from '@backstage/backend-common';
-import { TransportStreamOptions } from 'winston-transport';
-import { UrlReader } from '@backstage/backend-common';
+import { Readable } from 'stream';
 
 /** @public */
 export declare interface BackendFeature {
@@ -49,48 +46,186 @@ export declare interface BackendRegistrationPoints {
     }): void;
 }
 
-/** @public */
-export declare type CacheService = PluginCacheManager;
-
 /**
+ * A pre-configured, storage agnostic cache client suitable for use by
+ * Backstage plugins.
+ *
  * @public
  */
-declare const cacheServiceRef: ServiceRef<PluginCacheManager, "plugin">;
+export declare interface CacheClient {
+    /**
+     * Reads data from a cache store for the given key. If no data was found,
+     * returns undefined.
+     */
+    get(key: string): Promise<JsonValue | undefined>;
+    /**
+     * Writes the given data to a cache store, associated with the given key. An
+     * optional TTL may also be provided, otherwise it defaults to the TTL that
+     * was provided when the client was instantiated.
+     */
+    set(key: string, value: JsonValue, options?: CacheClientSetOptions): Promise<void>;
+    /**
+     * Removes the given key from the cache store.
+     */
+    delete(key: string): Promise<void>;
+}
 
 /**
+ * Options given when constructing a {@link CacheClient}.
+ *
  * @public
  */
-export declare type ConfigService = Config;
+export declare type CacheClientOptions = {
+    /**
+     * An optional default TTL (in milliseconds) to be set when getting a client
+     * instance. If not provided, data will persist indefinitely by default (or
+     * can be configured per entry at set-time).
+     */
+    defaultTtl?: number;
+};
 
 /**
+ * Options passed to {@link CacheClient.set}.
+ *
  * @public
  */
-declare const configServiceRef: ServiceRef<Config, "root">;
+export declare type CacheClientSetOptions = {
+    /**
+     * Optional TTL in milliseconds. Defaults to the TTL provided when the client
+     * was set up (or no TTL if none are provided).
+     */
+    ttl?: number;
+};
 
-declare namespace coreServices {
-    export {
-        configServiceRef as config,
-        httpRouterServiceRef as httpRouter,
-        loggerServiceRef as logger,
-        urlReaderServiceRef as urlReader,
-        cacheServiceRef as cache,
-        databaseServiceRef as database,
-        discoveryServiceRef as discovery,
-        tokenManagerServiceRef as tokenManager,
-        permissionsServiceRef as permissions,
-        schedulerServiceRef as scheduler,
-        rootLoggerServiceRef as rootLogger,
-        pluginMetadataServiceRef as pluginMetadata,
-        lifecycleServiceRef as lifecycle
-    }
+/**
+ * Manages access to cache stores that plugins get.
+ *
+ * @public
+ */
+export declare interface CacheService {
+    /**
+     * Provides backend plugins cache connections for themselves.
+     *
+     * @remarks
+     *
+     * The purpose of this method is to allow plugins to get isolated data stores
+     * so that plugins are discouraged from cache-level integration and/or cache
+     * key collisions.
+     */
+    getClient: (options?: CacheClientOptions) => CacheClient;
 }
-export { coreServices }
 
 /**
  * @public
+ */
+export declare interface ConfigService extends Config {
+}
+
+/**
+ * All core services references
  *
+ * @public
+ */
+export declare namespace coreServices {
+    /**
+     * The service reference for the plugin scoped {@link CacheService}.
+     *
+     * @public
+     */
+    const cache: ServiceRef<CacheService, "plugin">;
+    /**
+     * The service reference for the root scoped {@link ConfigService}.
+     *
+     * @public
+     */
+    const config: ServiceRef<ConfigService, "root">;
+    /**
+     * The service reference for the plugin scoped {@link DatabaseService}.
+     *
+     * @public
+     */
+    const database: ServiceRef<DatabaseService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link DiscoveryService}.
+     *
+     * @public
+     */
+    const discovery: ServiceRef<DiscoveryService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link HttpRouterService}.
+     *
+     * @public
+     */
+    const httpRouter: ServiceRef<HttpRouterService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link LifecycleService}.
+     *
+     * @public
+     */
+    const lifecycle: ServiceRef<LifecycleService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link LoggerService}.
+     *
+     * @public
+     */
+    const logger: ServiceRef<LoggerService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link PermissionsService}.
+     *
+     * @public
+     */
+    const permissions: ServiceRef<PermissionsService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link PluginMetadataService}.
+     *
+     * @public
+     */
+    const pluginMetadata: ServiceRef<PluginMetadataService, "plugin">;
+    /**
+     * The service reference for the root scoped {@link RootHttpRouterService}.
+     *
+     * @public
+     */
+    const rootHttpRouter: ServiceRef<RootHttpRouterService, "root">;
+    /**
+     * The service reference for the root scoped {@link RootLifecycleService}.
+     *
+     * @public
+     */
+    const rootLifecycle: ServiceRef<RootLifecycleService, "root">;
+    /**
+     * The service reference for the root scoped {@link RootLoggerService}.
+     *
+     * @public
+     */
+    const rootLogger: ServiceRef<RootLoggerService, "root">;
+    /**
+     * The service reference for the plugin scoped {@link SchedulerService}.
+     *
+     * @public
+     */
+    const scheduler: ServiceRef<SchedulerService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link TokenManagerService}.
+     *
+     * @public
+     */
+    const tokenManager: ServiceRef<TokenManagerService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link UrlReaderService}.
+     *
+     * @public
+     */
+    const urlReader: ServiceRef<UrlReaderService, "plugin">;
+}
+
+/**
  * Creates a new backend module for a given plugin.
  *
+ * @public
+ *
+ * @remarks
+ *
  * The `moduleId` should be equal to the module-specific prefix of the exported name, such
  * that the full name is `moduleId + PluginId + "Module"`. For example, a GitHub entity
  * provider module for the `catalog` plugin might have the module ID `'githubEntityProvider'`,
@@ -98,59 +233,107 @@ export { coreServices }
  *
  * The `pluginId` should exactly match the `id` of the plugin that the module extends.
  */
-export declare function createBackendModule<TOptions extends object | undefined = undefined>(config: BackendModuleConfig<TOptions>): undefined extends TOptions ? (options?: TOptions) => BackendFeature : (options: TOptions) => BackendFeature;
+export declare function createBackendModule<TOptions extends MaybeOptions = undefined>(config: BackendModuleConfig<TOptions>): FactoryFunctionWithOptions<BackendFeature, TOptions>;
 
 /** @public */
-export declare function createBackendPlugin<TOptions extends object | undefined = undefined>(config: {
-    id: string;
-    register(reg: BackendRegistrationPoints, options: TOptions): void;
-}): undefined extends TOptions ? (options?: TOptions) => BackendFeature : (options: TOptions) => BackendFeature;
+export declare function createBackendPlugin<TOptions extends MaybeOptions = undefined>(config: BackendPluginConfig<TOptions>): FactoryFunctionWithOptions<BackendFeature, TOptions>;
 
 /** @public */
-export declare function createExtensionPoint<T>(options: {
-    id: string;
-}): ExtensionPoint<T>;
+export declare function createExtensionPoint<T>(config: ExtensionPointConfig): ExtensionPoint<T>;
 
 /**
  * @public
  */
 export declare function createServiceFactory<TService, TScope extends 'root' | 'plugin', TImpl extends TService, TDeps extends {
     [name in string]: ServiceRef<unknown>;
-}, TOpts extends object | undefined = undefined>(config: {
-    service: ServiceRef<TService, TScope>;
-    deps: TDeps;
-    factory(deps: ServiceRefsToInstances<TDeps, 'root'>, options: TOpts): TScope extends 'root' ? Promise<TImpl> : Promise<(deps: ServiceRefsToInstances<TDeps>) => Promise<TImpl>>;
-}): undefined extends TOpts ? (options?: TOpts) => ServiceFactory<TService> : (options: TOpts) => ServiceFactory<TService>;
-
-/** @public */
-export declare function createServiceRef<T>(options: {
-    id: string;
-    scope?: 'plugin';
-    defaultFactory?: (service: ServiceRef<T, 'plugin'>) => Promise<ServiceFactory<T> | (() => ServiceFactory<T>)>;
-}): ServiceRef<T, 'plugin'>;
+}, TOpts extends MaybeOptions = undefined>(config: ServiceFactoryConfig<TService, TScope, TImpl, TDeps, TOpts>): FactoryFunctionWithOptions<ServiceFactory<TService>, TOpts>;
 
-/** @public */
-export declare function createServiceRef<T>(options: {
-    id: string;
-    scope: 'root';
-    defaultFactory?: (service: ServiceRef<T, 'root'>) => Promise<ServiceFactory<T> | (() => ServiceFactory<T>)>;
-}): ServiceRef<T, 'root'>;
-
-/** @public */
-export declare type DatabaseService = PluginDatabaseManager;
+/**
+ * Creates a new service definition. This overload is used to create plugin scoped services.
+ *
+ * @public
+ */
+export declare function createServiceRef<TService>(config: ServiceRefConfig<TService, 'plugin'>): ServiceRef<TService, 'plugin'>;
 
 /**
+ * Creates a new service definition. This overload is used to create root scoped services.
+ *
  * @public
  */
-declare const databaseServiceRef: ServiceRef<PluginDatabaseManager, "plugin">;
+export declare function createServiceRef<TService>(config: ServiceRefConfig<TService, 'root'>): ServiceRef<TService, 'root'>;
 
-/** @public */
-export declare type DiscoveryService = PluginEndpointDiscovery;
+/**
+ * The DatabaseService manages access to databases that Plugins get.
+ *gs
+ * @public
+ */
+export declare interface DatabaseService {
+    /**
+     * getClient provides backend plugins database connections for itself.
+     *
+     * The purpose of this method is to allow plugins to get isolated data
+     * stores so that plugins are discouraged from database integration.
+     */
+    getClient(): Promise<Knex>;
+    /**
+     * This property is used to control the behavior of database migrations.
+     */
+    migrations?: {
+        /**
+         * skip database migrations. Useful if connecting to a read-only database.
+         *
+         * @defaultValue false
+         */
+        skip?: boolean;
+    };
+}
 
 /**
+ * The DiscoveryService is used to provide a mechanism for backend
+ * plugins to discover the endpoints for itself or other backend plugins.
+ *
+ * The purpose of the discovery API is to allow for many different deployment
+ * setups and routing methods through a central configuration, instead
+ * of letting each individual plugin manage that configuration.
+ *
+ * Implementations of the discovery API can be as simple as a URL pattern
+ * using the pluginId, but could also have overrides for individual plugins,
+ * or query a separate discovery service.
+ *
  * @public
  */
-declare const discoveryServiceRef: ServiceRef<PluginEndpointDiscovery, "plugin">;
+export declare interface DiscoveryService {
+    /**
+     * Returns the internal HTTP base URL for a given plugin, without a trailing slash.
+     *
+     * The returned URL should point to an internal endpoint for the plugin, with
+     * the shortest route possible. The URL should be used for service-to-service
+     * communication within a Backstage backend deployment.
+     *
+     * This method must always be called just before making a request, as opposed to
+     * fetching the URL when constructing an API client. That is to ensure that more
+     * flexible routing patterns can be supported.
+     *
+     * For example, asking for the URL for `catalog` may return something
+     * like `http://10.1.2.3/api/catalog`
+     */
+    getBaseUrl(pluginId: string): Promise<string>;
+    /**
+     * Returns the external HTTP base backend URL for a given plugin, without a trailing slash.
+     *
+     * The returned URL should point to an external endpoint for the plugin, such that
+     * it is reachable from the Backstage frontend and other external services. The returned
+     * URL should be usable for example as a callback / webhook URL.
+     *
+     * The returned URL should be stable and in general not change unless other static
+     * or external configuration is changed. Changes should not come as a surprise
+     * to an operator of the Backstage backend.
+     *
+     * For example, asking for the URL for `catalog` may return something
+     * like `https://backstage.example.com/api/catalog`
+     */
+    getExternalBaseUrl(pluginId: string): Promise<string>;
+}
 
 /**
  * TODO
@@ -168,17 +351,24 @@ export declare type ExtensionPoint<T> = {
     $$ref: 'extension-point';
 };
 
+/** @public */
+export declare interface ExtensionPointConfig {
+    id: string;
+}
+
 /**
- * @public
+ * Helper type that makes the options argument optional if options are not required.
+ *
+ * @ignore
  */
-export declare interface HttpRouterService {
-    use(handler: Handler): void;
-}
+declare type FactoryFunctionWithOptions<TResult, TOptions> = undefined extends TOptions ? (options?: TOptions) => TResult : (options: TOptions) => TResult;
 
 /**
  * @public
  */
-declare const httpRouterServiceRef: ServiceRef<HttpRouterService, "plugin">;
+export declare interface HttpRouterService {
+    use(handler: Handler): void;
+}
 
 /**
  * @public
@@ -190,19 +380,20 @@ export declare interface LifecycleService {
     addShutdownHook(options: LifecycleServiceShutdownHook): void;
 }
 
-/**
- * @public
- */
-declare const lifecycleServiceRef: ServiceRef<LifecycleService, "plugin">;
-
 /**
  * @public
  **/
 export declare type LifecycleServiceShutdownHook = {
     fn: () => void | Promise<void>;
+    /**
+     * Optional {@link LoggerService} that will be used for logging instead of the default logger.
+     */
+    logger?: LoggerService;
 };
 
 /**
+ * A service that provides a logging facility.
+ *
  * @public
  */
 export declare interface LoggerService {
@@ -216,53 +407,283 @@ export declare interface LoggerService {
 /**
  * @public
  */
-declare const loggerServiceRef: ServiceRef<LoggerService, "plugin">;
+export declare type LogMeta = {
+    [name: string]: unknown;
+};
+
+/**
+ * Base type for options objects that aren't required.
+ *
+ * @ignore
+ */
+declare type MaybeOptions = object | undefined;
 
 /** @public */
-export declare function loggerToWinstonLogger(logger: LoggerService, opts?: TransportStreamOptions): Logger;
+export declare interface PermissionsService extends PermissionEvaluator {
+}
 
 /**
  * @public
  */
-export declare type LogMeta = {
-    [name: string]: unknown;
+export declare interface PluginMetadataService {
+    getId(): string;
+}
+
+/**
+ * An options object for {@link UrlReaderService.readTree} operations.
+ *
+ * @public
+ */
+export declare type ReadTreeOptions = {
+    /**
+     * A filter that can be used to select which files should be included.
+     *
+     * @remarks
+     *
+     * The path passed to the filter function is the relative path from the URL
+     * that the file tree is fetched from, without any leading '/'.
+     *
+     * For example, given the URL https://github.com/my/repo/tree/master/my-dir, a file
+     * at https://github.com/my/repo/blob/master/my-dir/my-subdir/my-file.txt will
+     * be represented as my-subdir/my-file.txt
+     *
+     * If no filter is provided, all files are extracted.
+     */
+    filter?(path: string, info?: {
+        size: number;
+    }): boolean;
+    /**
+     * An ETag which can be provided to check whether a
+     * {@link UrlReaderService.readTree} response has changed from a previous execution.
+     *
+     * @remarks
+     *
+     * In the {@link UrlReaderService.readTree} response, an ETag is returned along with
+     * the tree blob. The ETag is a unique identifier of the tree blob, usually
+     * the commit SHA or ETag from the target.
+     *
+     * When an ETag is given as a request option, {@link UrlReaderService.readTree} will
+     * first compare the ETag against the ETag on the target branch. If they
+     * match, {@link UrlReaderService.readTree} will throw a
+     * {@link @backstage/errors#NotModifiedError} indicating that the response
+     * will not differ from the previous response which included this particular
+     * ETag. If they do not match, {@link UrlReaderService.readTree} will return the
+     * rest of the response along with a new ETag.
+     */
+    etag?: string;
+    /**
+     * An abort signal to pass down to the underlying request.
+     *
+     * @remarks
+     *
+     * Not all reader implementations may take this field into account.
+     */
+    signal?: AbortSignal;
 };
 
-/** @public */
-export declare type PermissionsService = PermissionEvaluator | PermissionAuthorizer;
+/**
+ * A response object for {@link UrlReaderService.readTree} operations.
+ *
+ * @public
+ */
+export declare type ReadTreeResponse = {
+    /**
+     * Returns an array of all the files inside the tree, and corresponding
+     * functions to read their content.
+     */
+    files(): Promise<ReadTreeResponseFile[]>;
+    /**
+     * Returns the tree contents as a binary archive, using a stream.
+     */
+    archive(): Promise<NodeJS.ReadableStream>;
+    /**
+     * Extracts the tree response into a directory and returns the path of the
+     * directory.
+     *
+     * **NOTE**: It is the responsibility of the caller to remove the directory after use.
+     */
+    dir(options?: ReadTreeResponseDirOptions): Promise<string>;
+    /**
+     * Etag returned by content provider.
+     *
+     * @remarks
+     *
+     * Can be used to compare and cache responses when doing subsequent calls.
+     */
+    etag: string;
+};
 
 /**
+ * Options that control {@link ReadTreeResponse.dir} execution.
+ *
  * @public
  */
-declare const permissionsServiceRef: ServiceRef<PermissionsService, "plugin">;
+export declare type ReadTreeResponseDirOptions = {
+    /**
+     * The directory to write files to.
+     *
+     * @remarks
+     *
+     * Defaults to the OS tmpdir, or `backend.workingDirectory` if set in config.
+     */
+    targetDir?: string;
+};
 
 /**
+ * Represents a single file in a {@link UrlReaderService.readTree} response.
+ *
  * @public
  */
-export declare interface PluginMetadataService {
-    getId(): string;
-}
+export declare type ReadTreeResponseFile = {
+    path: string;
+    content(): Promise<Buffer>;
+};
 
 /**
+ * An options object for readUrl operations.
+ *
  * @public
  */
-declare const pluginMetadataServiceRef: ServiceRef<PluginMetadataService, "plugin">;
+export declare type ReadUrlOptions = {
+    /**
+     * An ETag which can be provided to check whether a
+     * {@link UrlReaderService.readUrl} response has changed from a previous execution.
+     *
+     * @remarks
+     *
+     * In the {@link UrlReaderService.readUrl} response, an ETag is returned along with
+     * the data. The ETag is a unique identifier of the data, usually the commit
+     * SHA or ETag from the target.
+     *
+     * When an ETag is given in ReadUrlOptions, {@link UrlReaderService.readUrl} will
+     * first compare the ETag against the ETag of the target. If they match,
+     * {@link UrlReaderService.readUrl} will throw a
+     * {@link @backstage/errors#NotModifiedError} indicating that the response
+     * will not differ from the previous response which included this particular
+     * ETag. If they do not match, {@link UrlReaderService.readUrl} will return the rest
+     * of the response along with a new ETag.
+     */
+    etag?: string;
+    /**
+     * An abort signal to pass down to the underlying request.
+     *
+     * @remarks
+     *
+     * Not all reader implementations may take this field into account.
+     */
+    signal?: AbortSignal;
+};
 
-/** @public */
-export declare type RootLoggerService = LoggerService;
+/**
+ * A response object for {@link UrlReaderService.readUrl} operations.
+ *
+ * @public
+ */
+export declare type ReadUrlResponse = {
+    /**
+     * Returns the data that was read from the remote URL.
+     */
+    buffer(): Promise<Buffer>;
+    /**
+     * Returns the data that was read from the remote URL as a Readable stream.
+     *
+     * @remarks
+     *
+     * This method will be required in a future release.
+     */
+    stream?(): Readable;
+    /**
+     * Etag returned by content provider.
+     *
+     * @remarks
+     *
+     * Can be used to compare and cache responses when doing subsequent calls.
+     */
+    etag?: string;
+};
 
 /**
  * @public
  */
-declare const rootLoggerServiceRef: ServiceRef<LoggerService, "root">;
+export declare interface RootHttpRouterService {
+    /**
+     * Registers a handler at the root of the backend router.
+     * The path is required and may not be empty.
+     */
+    use(path: string, handler: Handler): void;
+}
+
+/** @public */
+export declare interface RootLifecycleService extends LifecycleService {
+}
+
+/** @public */
+export declare interface RootLoggerService extends LoggerService {
+}
 
 /** @public */
-export declare type SchedulerService = PluginTaskScheduler;
+export declare interface SchedulerService extends PluginTaskScheduler {
+}
 
 /**
+ * An options object for search operations.
+ *
  * @public
  */
-declare const schedulerServiceRef: ServiceRef<PluginTaskScheduler, "plugin">;
+export declare type SearchOptions = {
+    /**
+     * An etag can be provided to check whether the search response has changed from a previous execution.
+     *
+     * In the search() response, an etag is returned along with the files. The etag is a unique identifier
+     * of the current tree, usually the commit SHA or etag from the target.
+     *
+     * When an etag is given in SearchOptions, search will first compare the etag against the etag
+     * on the target branch. If they match, search will throw a NotModifiedError indicating that the search
+     * response will not differ from the previous response which included this particular etag. If they mismatch,
+     * search will return the rest of SearchResponse along with a new etag.
+     */
+    etag?: string;
+    /**
+     * An abort signal to pass down to the underlying request.
+     *
+     * @remarks
+     *
+     * Not all reader implementations may take this field into account.
+     */
+    signal?: AbortSignal;
+};
+
+/**
+ * The output of a search operation.
+ *
+ * @public
+ */
+export declare type SearchResponse = {
+    /**
+     * The files that matched the search query.
+     */
+    files: SearchResponseFile[];
+    /**
+     * A unique identifier of the current remote tree, usually the commit SHA or etag from the target.
+     */
+    etag: string;
+};
+
+/**
+ * Represents a single file in a search response.
+ *
+ * @public
+ */
+export declare type SearchResponseFile = {
+    /**
+     * The full URL to the file.
+     */
+    url: string;
+    /**
+     * The binary contents of the file.
+     */
+    content(): Promise<Buffer>;
+};
 
 /** @public */
 export declare type ServiceFactory<TService = unknown> = {
@@ -287,6 +708,22 @@ export declare type ServiceFactory<TService = unknown> = {
     }) => Promise<TService>>;
 };
 
+/** @public */
+export declare interface ServiceFactoryConfig<TService, TScope extends 'root' | 'plugin', TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}, TOpts extends MaybeOptions = undefined> {
+    service: ServiceRef<TService, TScope>;
+    deps: TDeps;
+    factory(deps: ServiceRefsToInstances<TDeps, 'root'>, options: TOpts): TScope extends 'root' ? Promise<TImpl> : Promise<(deps: ServiceRefsToInstances<TDeps>) => Promise<TImpl>>;
+}
+
+/**
+ * Represents either a {@link ServiceFactory} or a function that returns one.
+ *
+ * @public
+ */
+export declare type ServiceFactoryOrFunction<TService = unknown> = ServiceFactory<TService> | (() => ServiceFactory<TService>);
+
 /**
  * TODO
  *
@@ -313,6 +750,13 @@ export declare type ServiceRef<TService, TScope extends 'root' | 'plugin' = 'roo
     $$ref: 'service';
 };
 
+/** @public */
+export declare interface ServiceRefConfig<TService, TScope extends 'root' | 'plugin'> {
+    id: string;
+    scope?: TScope;
+    defaultFactory?: (service: ServiceRef<TService, TScope>) => Promise<ServiceFactoryOrFunction<TService>>;
+}
+
 /** @ignore */
 declare type ServiceRefsToInstances<T extends {
     [key in string]: ServiceRef<unknown>;
@@ -322,25 +766,54 @@ declare type ServiceRefsToInstances<T extends {
     }[keyof T]]: T[name] extends ServiceRef<infer TImpl> ? TImpl : never;
 };
 
-/** @public */
-export declare type TokenManagerService = TokenManager;
-
 /**
+ * Interface for creating and validating tokens.
+ *
  * @public
  */
-declare const tokenManagerServiceRef: ServiceRef<TokenManager, "plugin">;
+export declare interface TokenManagerService {
+    /**
+     * Fetches a valid token.
+     *
+     * @remarks
+     *
+     * Tokens are valid for roughly one hour; the actual deadline is set in the
+     * payload `exp` claim. Never hold on to tokens for reuse; always ask for a
+     * new one for each outgoing request. This ensures that you always get a
+     * valid, fresh one.
+     */
+    getToken(): Promise<{
+        token: string;
+    }>;
+    /**
+     * Validates a given token.
+     */
+    authenticate(token: string): Promise<void>;
+}
 
 /** @public */
 export declare type TypesToServiceRef<T> = {
     [key in keyof T]: ServiceRef<T[key]>;
 };
 
-/** @public */
-export declare type UrlReaderService = UrlReader;
-
 /**
+ * A generic interface for fetching plain data from URLs.
+ *
  * @public
  */
-declare const urlReaderServiceRef: ServiceRef<UrlReader, "plugin">;
+export declare interface UrlReaderService {
+    /**
+     * Reads a single file and return its content.
+     */
+    readUrl(url: string, options?: ReadUrlOptions): Promise<ReadUrlResponse>;
+    /**
+     * Reads a full or partial file tree.
+     */
+    readTree(url: string, options?: ReadTreeOptions): Promise<ReadTreeResponse>;
+    /**
+     * Searches for a file in a tree using a glob pattern.
+     */
+    search(url: string, options?: SearchOptions): Promise<SearchResponse>;
+}
 
 export { }