@backstage/backend-plugin-api 0.4.0-next.2 → 0.4.1-next.0

package/dist/index.d.ts

@@ -1,408 +1,361 @@
-/**
- * Core API used by Backstage backend plugins.
- *
- * @packageDocumentation
- */
-
 /// <reference types="node" />
-
-import { Config } from '@backstage/config';
-import { Handler } from 'express';
 import { IdentityApi } from '@backstage/plugin-auth-node';
-import { JsonObject } from '@backstage/types';
-import { JsonValue } from '@backstage/types';
-import { Knex } from 'knex';
-import { PermissionEvaluator } from '@backstage/plugin-permission-common';
-import { PluginTaskScheduler } from '@backstage/backend-tasks';
 import { Readable } from 'stream';
+import { PluginTaskScheduler } from '@backstage/backend-tasks';
+import { JsonObject, JsonValue } from '@backstage/types';
+import { Handler } from 'express';
+import { PermissionEvaluator } from '@backstage/plugin-permission-common';
+import { Knex } from 'knex';
+import { Config } from '@backstage/config';
 
 /** @public */
-export declare interface BackendFeature {
-    $$type: '@backstage/BackendFeature';
+interface IdentityService extends IdentityApi {
 }
 
 /**
- * The configuration options passed to {@link createBackendModule}.
+ * A generic interface for fetching plain data from URLs.
  *
  * @public
- * @see {@link https://backstage.io/docs/backend-system/architecture/modules | The architecture of modules}
- * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
  */
-export declare interface BackendModuleConfig {
+interface UrlReaderService {
     /**
-     * The ID of this plugin.
-     *
-     * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
+     * Reads a single file and return its content.
      */
-    pluginId: string;
+    readUrl(url: string, options?: ReadUrlOptions): Promise<ReadUrlResponse>;
     /**
-     * Should exactly match the `id` of the plugin that the module extends.
+     * Reads a full or partial file tree.
      */
-    moduleId: string;
-    register(reg: BackendModuleRegistrationPoints): void;
-}
-
-/**
- * The callbacks passed to the `register` method of a backend module.
- *
- * @public
- */
-export declare interface BackendModuleRegistrationPoints {
-    registerInit<Deps extends {
-        [name in string]: unknown;
-    }>(options: {
-        deps: {
-            [name in keyof Deps]: ServiceRef<Deps[name]> | ExtensionPoint<Deps[name]>;
-        };
-        init(deps: Deps): Promise<void>;
-    }): void;
+    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>;
 }
-
 /**
- * The configuration options passed to {@link createBackendPlugin}.
+ * An options object for readUrl operations.
  *
  * @public
- * @see {@link https://backstage.io/docs/backend-system/architecture/plugins | The architecture of plugins}
- * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
  */
-export declare interface BackendPluginConfig {
+declare type ReadUrlOptions = {
     /**
-     * The ID of this plugin.
+     * An ETag which can be provided to check whether a
+     * {@link UrlReaderService.readUrl} response has changed from a previous execution.
      *
-     * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
+     * @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.
      */
-    pluginId: string;
-    register(reg: BackendPluginRegistrationPoints): void;
-}
-
-/**
- * The callbacks passed to the `register` method of a backend plugin.
- *
- * @public
- */
-export declare interface BackendPluginRegistrationPoints {
-    registerExtensionPoint<TExtensionPoint>(ref: ExtensionPoint<TExtensionPoint>, impl: TExtensionPoint): void;
-    registerInit<Deps extends {
-        [name in string]: unknown;
-    }>(options: {
-        deps: {
-            [name in keyof Deps]: ServiceRef<Deps[name]>;
-        };
-        init(deps: Deps): Promise<void>;
-    }): void;
-}
-
+    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;
+};
 /**
- * A pre-configured, storage agnostic cache client suitable for use by
- * Backstage plugins.
+ * A response object for {@link UrlReaderService.readUrl} operations.
  *
  * @public
  */
-export declare interface CacheClient {
+declare type ReadUrlResponse = {
     /**
-     * Reads data from a cache store for the given key. If no data was found,
-     * returns undefined.
+     * Returns the data that was read from the remote URL.
      */
-    get(key: string): Promise<JsonValue | undefined>;
+    buffer(): Promise<Buffer>;
     /**
-     * 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.
+     * Returns the data that was read from the remote URL as a Readable stream.
+     *
+     * @remarks
+     *
+     * This method will be required in a future release.
      */
-    set(key: string, value: JsonValue, options?: CacheClientSetOptions): Promise<void>;
+    stream?(): Readable;
     /**
-     * Removes the given key from the cache store.
+     * Etag returned by content provider.
+     *
+     * @remarks
+     *
+     * Can be used to compare and cache responses when doing subsequent calls.
      */
-    delete(key: string): Promise<void>;
-}
-
+    etag?: string;
+};
 /**
- * Options given when constructing a {@link CacheClient}.
+ * An options object for {@link UrlReaderService.readTree} operations.
  *
  * @public
  */
-export declare type CacheClientOptions = {
+declare type ReadTreeOptions = {
     /**
-     * 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).
+     * 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.
      */
-    defaultTtl?: number;
+    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;
 };
-
 /**
- * Options passed to {@link CacheClient.set}.
+ * Options that control {@link ReadTreeResponse.dir} execution.
  *
  * @public
  */
-export declare type CacheClientSetOptions = {
+declare type ReadTreeResponseDirOptions = {
     /**
-     * Optional TTL in milliseconds. Defaults to the TTL provided when the client
-     * was set up (or no TTL if none are provided).
+     * The directory to write files to.
+     *
+     * @remarks
+     *
+     * Defaults to the OS tmpdir, or `backend.workingDirectory` if set in config.
      */
-    ttl?: number;
+    targetDir?: string;
 };
-
 /**
- * Manages access to cache stores that plugins get.
+ * A response object for {@link UrlReaderService.readTree} operations.
  *
  * @public
  */
-export declare interface CacheService {
+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>;
     /**
-     * Provides backend plugins cache connections for themselves.
+     * Etag returned by content provider.
      *
      * @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.
+     * Can be used to compare and cache responses when doing subsequent calls.
      */
-    getClient: (options?: CacheClientOptions) => CacheClient;
-}
-
+    etag: string;
+};
 /**
+ * Represents a single file in a {@link UrlReaderService.readTree} response.
+ *
  * @public
  */
-export declare interface ConfigService extends Config {
-}
-
+declare type ReadTreeResponseFile = {
+    path: string;
+    content(): Promise<Buffer>;
+};
 /**
- * All core services references
+ * An options object for search operations.
  *
  * @public
  */
-export declare namespace coreServices {
+declare type SearchOptions = {
     /**
-     * The service reference for the plugin scoped {@link CacheService}.
+     * An etag can be provided to check whether the search response has changed from a previous execution.
      *
-     * @public
-     */
-    const cache: ServiceRef<CacheService, "plugin">;
-    /**
-     * The service reference for the root scoped {@link ConfigService}.
+     * 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.
      *
-     * @public
+     * 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.
      */
-    const config: ServiceRef<ConfigService, "root">;
+    etag?: string;
     /**
-     * The service reference for the plugin scoped {@link DatabaseService}.
+     * An abort signal to pass down to the underlying request.
      *
-     * @public
+     * @remarks
+     *
+     * Not all reader implementations may take this field into account.
      */
-    const database: ServiceRef<DatabaseService, "plugin">;
+    signal?: AbortSignal;
+};
+/**
+ * The output of a search operation.
+ *
+ * @public
+ */
+declare type SearchResponse = {
     /**
-     * The service reference for the plugin scoped {@link DiscoveryService}.
-     *
-     * @public
+     * The files that matched the search query.
      */
-    const discovery: ServiceRef<DiscoveryService, "plugin">;
+    files: SearchResponseFile[];
     /**
-     * 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
+     * A unique identifier of the current remote tree, usually the commit SHA or etag from the target.
      */
-    const rootLifecycle: ServiceRef<RootLifecycleService, "root">;
+    etag: string;
+};
+/**
+ * Represents a single file in a search response.
+ *
+ * @public
+ */
+declare type SearchResponseFile = {
     /**
-     * The service reference for the root scoped {@link RootLoggerService}.
-     *
-     * @public
+     * The full URL to the file.
      */
-    const rootLogger: ServiceRef<RootLoggerService, "root">;
+    url: string;
     /**
-     * The service reference for the plugin scoped {@link SchedulerService}.
-     *
-     * @public
+     * The binary contents of the file.
      */
-    const scheduler: ServiceRef<SchedulerService, "plugin">;
+    content(): Promise<Buffer>;
+};
+
+/**
+ * Interface for creating and validating tokens.
+ *
+ * @public
+ */
+interface TokenManagerService {
     /**
-     * The service reference for the plugin scoped {@link TokenManagerService}.
+     * Fetches a valid token.
      *
-     * @public
-     */
-    const tokenManager: ServiceRef<TokenManagerService, "plugin">;
-    /**
-     * The service reference for the plugin scoped {@link UrlReaderService}.
+     * @remarks
      *
-     * @public
+     * 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.
      */
-    const urlReader: ServiceRef<UrlReaderService, "plugin">;
+    getToken(): Promise<{
+        token: string;
+    }>;
     /**
-     * The service reference for the plugin scoped {@link IdentityService}.
-     *
-     * @public
+     * Validates a given token.
      */
-    const identity: ServiceRef<IdentityService, "plugin">;
+    authenticate(token: string): Promise<void>;
 }
 
-/**
- * Creates a new backend module for a given plugin.
- *
- * @public
- * @see {@link https://backstage.io/docs/backend-system/architecture/modules | The architecture of modules}
- * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
- */
-export declare function createBackendModule<TOptions extends [options?: object] = []>(config: BackendModuleConfig | ((...params: TOptions) => BackendModuleConfig)): (...params: TOptions) => BackendFeature;
-
-/**
- * Creates a new backend plugin.
- *
- * @public
- * @see {@link https://backstage.io/docs/backend-system/architecture/plugins | The architecture of plugins}
- * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
- */
-export declare function createBackendPlugin<TOptions extends [options?: object] = []>(config: BackendPluginConfig | ((...params: TOptions) => BackendPluginConfig)): (...params: TOptions) => BackendFeature;
-
-/**
- * Creates a new backend extension point.
- *
- * @public
- * @see {@link https://backstage.io/docs/backend-system/architecture/extension-points | The architecture of extension points}
- */
-export declare function createExtensionPoint<T>(config: ExtensionPointConfig): ExtensionPoint<T>;
+/** @public */
+interface SchedulerService extends PluginTaskScheduler {
+}
 
 /**
- * Creates a root scoped service factory without options.
+ * A service that provides a logging facility.
  *
  * @public
- * @param config - The service factory configuration.
  */
-export declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
-    [name in string]: ServiceRef<unknown>;
-}, TOpts extends object | undefined = undefined>(config: RootServiceFactoryConfig<TService, TImpl, TDeps>): () => ServiceFactory<TService>;
+interface LoggerService {
+    error(message: string, meta?: Error | JsonObject): void;
+    warn(message: string, meta?: Error | JsonObject): void;
+    info(message: string, meta?: Error | JsonObject): void;
+    debug(message: string, meta?: Error | JsonObject): void;
+    child(meta: JsonObject): LoggerService;
+}
 
-/**
- * Creates a root scoped service factory with optional options.
- *
- * @public
- * @param config - The service factory configuration.
- */
-export declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
-    [name in string]: ServiceRef<unknown>;
-}, TOpts extends object | undefined = undefined>(config: (options?: TOpts) => RootServiceFactoryConfig<TService, TImpl, TDeps>): (options?: TOpts) => ServiceFactory<TService>;
+/** @public */
+interface RootLoggerService extends LoggerService {
+}
 
 /**
- * Creates a root scoped service factory with required options.
- *
  * @public
- * @param config - The service factory configuration.
  */
-export declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
-    [name in string]: ServiceRef<unknown>;
-}, TOpts extends object | undefined = undefined>(config: (options: TOpts) => RootServiceFactoryConfig<TService, TImpl, TDeps>): (options: TOpts) => ServiceFactory<TService>;
-
+declare type LifecycleServiceShutdownHook = () => void | Promise<void>;
 /**
- * Creates a plugin scoped service factory without options.
- *
  * @public
- * @param config - The service factory configuration.
  */
-export declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
-    [name in string]: ServiceRef<unknown>;
-}, TContext = undefined, TOpts extends object | undefined = undefined>(config: PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps>): () => ServiceFactory<TService>;
-
+interface LifecycleServiceShutdownOptions {
+    /**
+     * Optional {@link LoggerService} that will be used for logging instead of the default logger.
+     */
+    logger?: LoggerService;
+}
 /**
- * Creates a plugin scoped service factory with optional options.
- *
  * @public
- * @param config - The service factory configuration.
  */
-export declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
-    [name in string]: ServiceRef<unknown>;
-}, TContext = undefined, TOpts extends object | undefined = undefined>(config: (options?: TOpts) => PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps>): (options?: TOpts) => ServiceFactory<TService>;
+interface LifecycleService {
+    /**
+     * Register a function to be called when the backend is shutting down.
+     */
+    addShutdownHook(hook: LifecycleServiceShutdownHook, options?: LifecycleServiceShutdownOptions): void;
+}
 
-/**
- * Creates a plugin scoped service factory with required options.
- *
- * @public
- * @param config - The service factory configuration.
- */
-export declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
-    [name in string]: ServiceRef<unknown>;
-}, TContext = undefined, TOpts extends object | undefined = undefined>(config: PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps> | ((options: TOpts) => PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps>)): (options: TOpts) => ServiceFactory<TService>;
+/** @public */
+interface RootLifecycleService extends LifecycleService {
+}
 
 /**
- * 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'>;
+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;
+}
 
 /**
- * Creates a new service definition. This overload is used to create root scoped services.
- *
  * @public
  */
-export declare function createServiceRef<TService>(config: ServiceRefConfig<TService, 'root'>): ServiceRef<TService, 'root'>;
+interface PluginMetadataService {
+    getId(): string;
+}
 
-/**
- * Creates a shared backend environment which can be used to create multiple
- * backends.
- *
- * @public
- */
-export declare function createSharedEnvironment<TOptions extends [options?: object] = []>(config: SharedBackendEnvironmentConfig | ((...params: TOptions) => SharedBackendEnvironmentConfig)): (...options: TOptions) => SharedBackendEnvironment;
+/** @public */
+interface PermissionsService extends PermissionEvaluator {
+}
 
 /**
- * The DatabaseService manages access to databases that Plugins get.
- *
  * @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;
-    };
+interface HttpRouterService {
+    use(handler: Handler): void;
 }
 
 /**
@@ -419,7 +372,7 @@ export declare interface DatabaseService {
  *
  * @public
  */
-export declare interface DiscoveryService {
+interface DiscoveryService {
     /**
      * Returns the internal HTTP base URL for a given plugin, without a trailing slash.
      *
@@ -453,99 +406,107 @@ export declare interface DiscoveryService {
 }
 
 /**
- * TODO
+ * The DatabaseService manages access to databases that Plugins get.
  *
  * @public
  */
-export declare type ExtensionPoint<T> = {
-    id: string;
+interface DatabaseService {
     /**
-     * Utility for getting the type of the extension point, using `typeof extensionPoint.T`.
-     * Attempting to actually read this value will result in an exception.
+     * 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.
      */
-    T: T;
-    toString(): string;
-    $$type: '@backstage/ExtensionPoint';
-};
-
-/**
- * The configuration options passed to {@link createExtensionPoint}.
- *
- * @public
- * @see {@link https://backstage.io/docs/backend-system/architecture/extension-points | The architecture of extension points}
- * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
- */
-export declare interface ExtensionPointConfig {
+    getClient(): Promise<Knex>;
     /**
-     * The ID of this extension point.
-     *
-     * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
+     * This property is used to control the behavior of database migrations.
      */
-    id: string;
+    migrations?: {
+        /**
+         * skip database migrations. Useful if connecting to a read-only database.
+         *
+         * @defaultValue false
+         */
+        skip?: boolean;
+    };
 }
 
 /**
  * @public
  */
-export declare interface HttpRouterService {
-    use(handler: Handler): void;
-}
-
-/** @public */
-export declare interface IdentityService extends IdentityApi {
+interface ConfigService extends Config {
 }
 
 /**
+ * TODO
+ *
  * @public
  */
-export declare interface LifecycleService {
+declare type ServiceRef<TService, TScope extends 'root' | 'plugin' = 'root' | 'plugin'> = {
+    id: string;
     /**
-     * Register a function to be called when the backend is shutting down.
+     * This determines the scope at which this service is available.
+     *
+     * Root scoped services are available to all other services but
+     * may only depend on other root scoped services.
+     *
+     * Plugin scoped services are only available to other plugin scoped
+     * services but may depend on all other services.
      */
-    addShutdownHook(hook: LifecycleServiceShutdownHook, options?: LifecycleServiceShutdownOptions): void;
-}
-
-/**
- * @public
- */
-export declare type LifecycleServiceShutdownHook = () => void | Promise<void>;
-
-/**
- * @public
- */
-export declare interface LifecycleServiceShutdownOptions {
+    scope: TScope;
     /**
-     * Optional {@link LoggerService} that will be used for logging instead of the default logger.
+     * Utility for getting the type of the service, using `typeof serviceRef.T`.
+     * Attempting to actually read this value will result in an exception.
      */
-    logger?: LoggerService;
+    T: TService;
+    toString(): string;
+    $$type: '@backstage/ServiceRef';
+};
+/** @public */
+interface ServiceFactory<TService = unknown, TScope extends 'plugin' | 'root' = 'plugin' | 'root'> {
+    $$type: '@backstage/ServiceFactory';
+    service: ServiceRef<TService, TScope>;
 }
-
 /**
- * A service that provides a logging facility.
+ * Represents either a {@link ServiceFactory} or a function that returns one.
  *
  * @public
  */
-export declare interface LoggerService {
-    error(message: string, meta?: Error | JsonObject): void;
-    warn(message: string, meta?: Error | JsonObject): void;
-    info(message: string, meta?: Error | JsonObject): void;
-    debug(message: string, meta?: Error | JsonObject): void;
-    child(meta: JsonObject): LoggerService;
-}
-
+declare type ServiceFactoryOrFunction = ServiceFactory | (() => ServiceFactory);
 /** @public */
-export declare interface PermissionsService extends PermissionEvaluator {
+interface ServiceRefConfig<TService, TScope extends 'root' | 'plugin'> {
+    id: string;
+    scope?: TScope;
+    defaultFactory?: (service: ServiceRef<TService, TScope>) => Promise<ServiceFactoryOrFunction>;
 }
-
 /**
+ * Creates a new service definition. This overload is used to create plugin scoped services.
+ *
  * @public
  */
-export declare interface PluginMetadataService {
-    getId(): string;
+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 function createServiceRef<TService>(config: ServiceRefConfig<TService, 'root'>): ServiceRef<TService, 'root'>;
+/** @ignore */
+declare type ServiceRefsToInstances<T extends {
+    [key in string]: ServiceRef<unknown>;
+}, TScope extends 'root' | 'plugin' = 'root' | 'plugin'> = {
+    [key in keyof T as T[key]['scope'] extends TScope ? key : never]: T[key]['T'];
+};
+/** @public */
+interface RootServiceFactoryConfig<TService, TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}> {
+    service: ServiceRef<TService, 'root'>;
+    deps: TDeps;
+    factory(deps: ServiceRefsToInstances<TDeps, 'root'>): TImpl | Promise<TImpl>;
 }
-
 /** @public */
-export declare interface PluginServiceFactoryConfig<TService, TContext, TImpl extends TService, TDeps extends {
+interface PluginServiceFactoryConfig<TService, TContext, TImpl extends TService, TDeps extends {
     [name in string]: ServiceRef<unknown>;
 }> {
     service: ServiceRef<TService, 'plugin'>;
@@ -553,404 +514,366 @@ export declare interface PluginServiceFactoryConfig<TService, TContext, TImpl ex
     createRootContext?(deps: ServiceRefsToInstances<TDeps, 'root'>): TContext | Promise<TContext>;
     factory(deps: ServiceRefsToInstances<TDeps>, context: TContext): TImpl | Promise<TImpl>;
 }
+/**
+ * Creates a root scoped service factory without options.
+ *
+ * @public
+ * @param config - The service factory configuration.
+ */
+declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}, TOpts extends object | undefined = undefined>(config: RootServiceFactoryConfig<TService, TImpl, TDeps>): () => ServiceFactory<TService, 'root'>;
+/**
+ * Creates a root scoped service factory with optional options.
+ *
+ * @public
+ * @param config - The service factory configuration.
+ */
+declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}, TOpts extends object | undefined = undefined>(config: (options?: TOpts) => RootServiceFactoryConfig<TService, TImpl, TDeps>): (options?: TOpts) => ServiceFactory<TService, 'root'>;
+/**
+ * Creates a root scoped service factory with required options.
+ *
+ * @public
+ * @param config - The service factory configuration.
+ */
+declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}, TOpts extends object | undefined = undefined>(config: (options: TOpts) => RootServiceFactoryConfig<TService, TImpl, TDeps>): (options: TOpts) => ServiceFactory<TService, 'root'>;
+/**
+ * Creates a plugin scoped service factory without options.
+ *
+ * @public
+ * @param config - The service factory configuration.
+ */
+declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}, TContext = undefined, TOpts extends object | undefined = undefined>(config: PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps>): () => ServiceFactory<TService, 'plugin'>;
+/**
+ * Creates a plugin scoped service factory with optional options.
+ *
+ * @public
+ * @param config - The service factory configuration.
+ */
+declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}, TContext = undefined, TOpts extends object | undefined = undefined>(config: (options?: TOpts) => PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps>): (options?: TOpts) => ServiceFactory<TService, 'plugin'>;
+/**
+ * Creates a plugin scoped service factory with required options.
+ *
+ * @public
+ * @param config - The service factory configuration.
+ */
+declare function createServiceFactory<TService, TImpl extends TService, TDeps extends {
+    [name in string]: ServiceRef<unknown>;
+}, TContext = undefined, TOpts extends object | undefined = undefined>(config: PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps> | ((options: TOpts) => PluginServiceFactoryConfig<TService, TContext, TImpl, TDeps>)): (options: TOpts) => ServiceFactory<TService, 'plugin'>;
 
 /**
- * An options object for {@link UrlReaderService.readTree} operations.
+ * Options passed to {@link CacheService.set}.
  *
  * @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;
+declare type CacheServiceSetOptions = {
     /**
-     * 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.
+     * Optional TTL in milliseconds. Defaults to the TTL provided when the client
+     * was set up (or no TTL if none are provided).
      */
-    etag?: string;
+    ttl?: number;
+};
+/**
+ * Options passed to {@link CacheService.withOptions}.
+ *
+ * @public
+ */
+declare type CacheServiceOptions = {
     /**
-     * An abort signal to pass down to the underlying request.
-     *
-     * @remarks
-     *
-     * Not all reader implementations may take this field into account.
+     * 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).
      */
-    signal?: AbortSignal;
+    defaultTtl?: number;
 };
-
 /**
- * A response object for {@link UrlReaderService.readTree} operations.
+ * A pre-configured, storage agnostic cache service suitable for use by
+ * Backstage plugins.
  *
  * @public
  */
-export declare type ReadTreeResponse = {
+interface CacheService {
     /**
-     * Returns an array of all the files inside the tree, and corresponding
-     * functions to read their content.
+     * Reads data from a cache store for the given key. If no data was found,
+     * returns undefined.
      */
-    files(): Promise<ReadTreeResponseFile[]>;
+    get<TValue extends JsonValue>(key: string): Promise<TValue | undefined>;
     /**
-     * Returns the tree contents as a binary archive, using a stream.
+     * 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.
      */
-    archive(): Promise<NodeJS.ReadableStream>;
+    set(key: string, value: JsonValue, options?: CacheServiceSetOptions): Promise<void>;
     /**
-     * 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.
+     * Removes the given key from the cache store.
      */
-    dir(options?: ReadTreeResponseDirOptions): Promise<string>;
+    delete(key: string): Promise<void>;
     /**
-     * Etag returned by content provider.
-     *
-     * @remarks
-     *
-     * Can be used to compare and cache responses when doing subsequent calls.
+     * Creates a new {@link CacheService} instance with the given options.
      */
-    etag: string;
-};
+    withOptions(options: CacheServiceOptions): CacheService;
+}
 
 /**
- * Options that control {@link ReadTreeResponse.dir} execution.
+ * All core services references
  *
  * @public
  */
-export declare type ReadTreeResponseDirOptions = {
+declare namespace coreServices {
     /**
-     * The directory to write files to.
-     *
-     * @remarks
+     * The service reference for the plugin scoped {@link CacheService}.
      *
-     * Defaults to the OS tmpdir, or `backend.workingDirectory` if set in config.
+     * @public
      */
-    targetDir?: string;
-};
-
-/**
- * Represents a single file in a {@link UrlReaderService.readTree} response.
- *
- * @public
- */
-export declare type ReadTreeResponseFile = {
-    path: string;
-    content(): Promise<Buffer>;
-};
-
-/**
- * An options object for readUrl operations.
- *
- * @public
- */
-export declare type ReadUrlOptions = {
+    const cache: ServiceRef<CacheService, "plugin">;
     /**
-     * An ETag which can be provided to check whether a
-     * {@link UrlReaderService.readUrl} response has changed from a previous execution.
+     * The service reference for the root scoped {@link ConfigService}.
      *
-     * @remarks
+     * @public
+     */
+    const config: ServiceRef<ConfigService, "root">;
+    /**
+     * The service reference for the plugin scoped {@link DatabaseService}.
      *
-     * 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.
+     * @public
+     */
+    const database: ServiceRef<DatabaseService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link DiscoveryService}.
      *
-     * 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.
+     * @public
      */
-    etag?: string;
+    const discovery: ServiceRef<DiscoveryService, "plugin">;
     /**
-     * An abort signal to pass down to the underlying request.
+     * The service reference for the plugin scoped {@link HttpRouterService}.
      *
-     * @remarks
+     * @public
+     */
+    const httpRouter: ServiceRef<HttpRouterService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link LifecycleService}.
      *
-     * Not all reader implementations may take this field into account.
+     * @public
      */
-    signal?: AbortSignal;
-};
-
-/**
- * A response object for {@link UrlReaderService.readUrl} operations.
- *
- * @public
- */
-export declare type ReadUrlResponse = {
+    const lifecycle: ServiceRef<LifecycleService, "plugin">;
     /**
-     * Returns the data that was read from the remote URL.
+     * The service reference for the plugin scoped {@link LoggerService}.
+     *
+     * @public
      */
-    buffer(): Promise<Buffer>;
+    const logger: ServiceRef<LoggerService, "plugin">;
     /**
-     * Returns the data that was read from the remote URL as a Readable stream.
+     * The service reference for the plugin scoped {@link PermissionsService}.
      *
-     * @remarks
+     * @public
+     */
+    const permissions: ServiceRef<PermissionsService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link PluginMetadataService}.
      *
-     * This method will be required in a future release.
+     * @public
      */
-    stream?(): Readable;
+    const pluginMetadata: ServiceRef<PluginMetadataService, "plugin">;
     /**
-     * Etag returned by content provider.
+     * The service reference for the root scoped {@link RootHttpRouterService}.
      *
-     * @remarks
+     * @public
+     */
+    const rootHttpRouter: ServiceRef<RootHttpRouterService, "root">;
+    /**
+     * The service reference for the root scoped {@link RootLifecycleService}.
      *
-     * Can be used to compare and cache responses when doing subsequent calls.
+     * @public
      */
-    etag?: string;
-};
-
-/**
- * @public
- */
-export declare interface RootHttpRouterService {
+    const rootLifecycle: ServiceRef<RootLifecycleService, "root">;
     /**
-     * Registers a handler at the root of the backend router.
-     * The path is required and may not be empty.
+     * The service reference for the root scoped {@link RootLoggerService}.
+     *
+     * @public
      */
-    use(path: string, handler: Handler): void;
-}
-
-/** @public */
-export declare interface RootLifecycleService extends LifecycleService {
-}
-
-/** @public */
-export declare interface RootLoggerService extends LoggerService {
-}
-
-/** @public */
-export declare interface RootServiceFactoryConfig<TService, TImpl extends TService, TDeps extends {
-    [name in string]: ServiceRef<unknown>;
-}> {
-    service: ServiceRef<TService, 'root'>;
-    deps: TDeps;
-    factory(deps: ServiceRefsToInstances<TDeps, 'root'>): TImpl | Promise<TImpl>;
-}
-
-/** @public */
-export declare interface SchedulerService extends PluginTaskScheduler {
-}
-
-/**
- * An options object for search operations.
- *
- * @public
- */
-export declare type SearchOptions = {
+    const rootLogger: ServiceRef<RootLoggerService, "root">;
     /**
-     * An etag can be provided to check whether the search response has changed from a previous execution.
+     * The service reference for the plugin scoped {@link SchedulerService}.
      *
-     * 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.
+     * @public
+     */
+    const scheduler: ServiceRef<SchedulerService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link TokenManagerService}.
      *
-     * 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.
+     * @public
      */
-    etag?: string;
+    const tokenManager: ServiceRef<TokenManagerService, "plugin">;
     /**
-     * An abort signal to pass down to the underlying request.
+     * The service reference for the plugin scoped {@link UrlReaderService}.
      *
-     * @remarks
+     * @public
+     */
+    const urlReader: ServiceRef<UrlReaderService, "plugin">;
+    /**
+     * The service reference for the plugin scoped {@link IdentityService}.
      *
-     * Not all reader implementations may take this field into account.
+     * @public
      */
-    signal?: AbortSignal;
-};
+    const identity: ServiceRef<IdentityService, "plugin">;
+}
 
 /**
- * The output of a search operation.
+ * The configuration options passed to {@link createSharedEnvironment}.
  *
  * @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;
-};
-
+interface SharedBackendEnvironmentConfig {
+    services?: ServiceFactoryOrFunction[];
+}
 /**
- * Represents a single file in a search response.
+ * An opaque type that represents the contents of a shared backend environment.
  *
  * @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> = {
-    scope: 'root';
-    service: ServiceRef<TService, 'root'>;
-    deps: {
-        [key in string]: ServiceRef<unknown>;
-    };
-    factory(deps: {
-        [key in string]: unknown;
-    }): Promise<TService>;
-} | {
-    scope: 'plugin';
-    service: ServiceRef<TService, 'plugin'>;
-    deps: {
-        [key in string]: ServiceRef<unknown>;
-    };
-    createRootContext?(deps: {
-        [key in string]: unknown;
-    }): Promise<unknown>;
-    factory(deps: {
-        [key in string]: unknown;
-    }, context: unknown): Promise<TService>;
-};
-
+interface SharedBackendEnvironment {
+    $$type: '@backstage/SharedBackendEnvironment';
+}
 /**
- * Represents either a {@link ServiceFactory} or a function that returns one.
+ * Creates a shared backend environment which can be used to create multiple
+ * backends.
  *
  * @public
  */
-export declare type ServiceFactoryOrFunction<TService = unknown> = ServiceFactory<TService> | (() => ServiceFactory<TService>);
+declare function createSharedEnvironment<TOptions extends [options?: object] = []>(config: SharedBackendEnvironmentConfig | ((...params: TOptions) => SharedBackendEnvironmentConfig)): (...options: TOptions) => SharedBackendEnvironment;
 
 /**
  * TODO
  *
  * @public
  */
-export declare type ServiceRef<TService, TScope extends 'root' | 'plugin' = 'root' | 'plugin'> = {
+declare type ExtensionPoint<T> = {
     id: string;
     /**
-     * This determines the scope at which this service is available.
-     *
-     * Root scoped services are available to all other services but
-     * may only depend on other root scoped services.
-     *
-     * Plugin scoped services are only available to other plugin scoped
-     * services but may depend on all other services.
-     */
-    scope: TScope;
-    /**
-     * Utility for getting the type of the service, using `typeof serviceRef.T`.
+     * Utility for getting the type of the extension point, using `typeof extensionPoint.T`.
      * Attempting to actually read this value will result in an exception.
      */
-    T: TService;
+    T: T;
     toString(): string;
-    $$type: '@backstage/ServiceRef';
-};
-
-/** @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>;
-}, TScope extends 'root' | 'plugin' = 'root' | 'plugin'> = {
-    [key in keyof T as T[key]['scope'] extends TScope ? key : never]: T[key]['T'];
+    $$type: '@backstage/ExtensionPoint';
 };
-
 /**
- * An opaque type that represents the contents of a shared backend environment.
+ * The callbacks passed to the `register` method of a backend plugin.
  *
  * @public
  */
-export declare interface SharedBackendEnvironment {
-    $$type: '@backstage/SharedBackendEnvironment';
+interface BackendPluginRegistrationPoints {
+    registerExtensionPoint<TExtensionPoint>(ref: ExtensionPoint<TExtensionPoint>, impl: TExtensionPoint): void;
+    registerInit<Deps extends {
+        [name in string]: unknown;
+    }>(options: {
+        deps: {
+            [name in keyof Deps]: ServiceRef<Deps[name]>;
+        };
+        init(deps: Deps): Promise<void>;
+    }): void;
 }
-
 /**
- * The configuration options passed to {@link createSharedEnvironment}.
+ * The callbacks passed to the `register` method of a backend module.
  *
  * @public
  */
-export declare interface SharedBackendEnvironmentConfig {
-    services?: ServiceFactoryOrFunction[];
+interface BackendModuleRegistrationPoints {
+    registerInit<Deps extends {
+        [name in string]: unknown;
+    }>(options: {
+        deps: {
+            [name in keyof Deps]: ServiceRef<Deps[name]> | ExtensionPoint<Deps[name]>;
+        };
+        init(deps: Deps): Promise<void>;
+    }): void;
+}
+/** @public */
+interface BackendFeature {
+    $$type: '@backstage/BackendFeature';
 }
 
 /**
- * Interface for creating and validating tokens.
+ * The configuration options passed to {@link createExtensionPoint}.
  *
  * @public
+ * @see {@link https://backstage.io/docs/backend-system/architecture/extension-points | The architecture of extension points}
+ * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
  */
-export declare interface TokenManagerService {
+interface ExtensionPointConfig {
     /**
-     * Fetches a valid token.
-     *
-     * @remarks
+     * The ID of this extension point.
      *
-     * 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.
+     * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
      */
-    authenticate(token: string): Promise<void>;
+    id: string;
 }
-
 /**
- * A generic interface for fetching plain data from URLs.
+ * Creates a new backend extension point.
  *
  * @public
+ * @see {@link https://backstage.io/docs/backend-system/architecture/extension-points | The architecture of extension points}
+ */
+declare function createExtensionPoint<T>(config: ExtensionPointConfig): ExtensionPoint<T>;
+/**
+ * The configuration options passed to {@link createBackendPlugin}.
+ *
+ * @public
+ * @see {@link https://backstage.io/docs/backend-system/architecture/plugins | The architecture of plugins}
+ * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
  */
-export declare interface UrlReaderService {
+interface BackendPluginConfig {
     /**
-     * Reads a single file and return its content.
+     * The ID of this plugin.
+     *
+     * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
      */
-    readUrl(url: string, options?: ReadUrlOptions): Promise<ReadUrlResponse>;
+    pluginId: string;
+    register(reg: BackendPluginRegistrationPoints): void;
+}
+/**
+ * Creates a new backend plugin.
+ *
+ * @public
+ * @see {@link https://backstage.io/docs/backend-system/architecture/plugins | The architecture of plugins}
+ * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
+ */
+declare function createBackendPlugin<TOptions extends [options?: object] = []>(config: BackendPluginConfig | ((...params: TOptions) => BackendPluginConfig)): (...params: TOptions) => BackendFeature;
+/**
+ * The configuration options passed to {@link createBackendModule}.
+ *
+ * @public
+ * @see {@link https://backstage.io/docs/backend-system/architecture/modules | The architecture of modules}
+ * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
+ */
+interface BackendModuleConfig {
     /**
-     * Reads a full or partial file tree.
+     * The ID of this plugin.
+     *
+     * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
      */
-    readTree(url: string, options?: ReadTreeOptions): Promise<ReadTreeResponse>;
+    pluginId: string;
     /**
-     * Searches for a file in a tree using a glob pattern.
+     * Should exactly match the `id` of the plugin that the module extends.
      */
-    search(url: string, options?: SearchOptions): Promise<SearchResponse>;
+    moduleId: string;
+    register(reg: BackendModuleRegistrationPoints): void;
 }
+/**
+ * Creates a new backend module for a given plugin.
+ *
+ * @public
+ * @see {@link https://backstage.io/docs/backend-system/architecture/modules | The architecture of modules}
+ * @see {@link https://backstage.io/docs/backend-system/architecture/naming-patterns | Recommended naming patterns}
+ */
+declare function createBackendModule<TOptions extends [options?: object] = []>(config: BackendModuleConfig | ((...params: TOptions) => BackendModuleConfig)): (...params: TOptions) => BackendFeature;
 
-export { }
+export { BackendFeature, BackendModuleConfig, BackendModuleRegistrationPoints, BackendPluginConfig, BackendPluginRegistrationPoints, CacheService, CacheServiceOptions, CacheServiceSetOptions, ConfigService, DatabaseService, DiscoveryService, ExtensionPoint, ExtensionPointConfig, HttpRouterService, IdentityService, LifecycleService, LifecycleServiceShutdownHook, LifecycleServiceShutdownOptions, LoggerService, PermissionsService, PluginMetadataService, PluginServiceFactoryConfig, ReadTreeOptions, ReadTreeResponse, ReadTreeResponseDirOptions, ReadTreeResponseFile, ReadUrlOptions, ReadUrlResponse, RootHttpRouterService, RootLifecycleService, RootLoggerService, RootServiceFactoryConfig, SchedulerService, SearchOptions, SearchResponse, SearchResponseFile, ServiceFactory, ServiceFactoryOrFunction, ServiceRef, ServiceRefConfig, SharedBackendEnvironment, SharedBackendEnvironmentConfig, TokenManagerService, UrlReaderService, coreServices, createBackendModule, createBackendPlugin, createExtensionPoint, createServiceFactory, createServiceRef, createSharedEnvironment };