@afora/core 0.0.7 → 0.0.8

package/dist/core/output/openapi-sink.d.ts

@@ -3,8 +3,93 @@ import type { OperationDescriptor } from "./types/output.interface.js";
 declare const METHODS: readonly ["get", "post", "put", "patch", "delete"];
 /** An HTTP method an operation can be routed to. */
 export type OpenAPIMethod = (typeof METHODS)[number];
+/** The status of a successful call of a route; `204` has no body. */
+export type RouteStatus = 200 | 201 | 202 | 204;
+/**
+ * A security scheme of the document (`components.securitySchemes`), as
+ * OpenAPI 3.1 writes it.
+ */
+export type OpenAPISecurityScheme = {
+    readonly type: "http";
+    /** `"bearer"`, `"basic"`... */
+    readonly scheme: string;
+    readonly bearerFormat?: string;
+    readonly description?: string;
+} | {
+    readonly type: "apiKey";
+    readonly name: string;
+    readonly in: "header" | "query" | "cookie";
+    readonly description?: string;
+} | {
+    readonly type: "oauth2";
+    readonly flows: {
+        readonly [flow: string]: unknown;
+    };
+    readonly description?: string;
+} | {
+    readonly type: "openIdConnect";
+    readonly openIdConnectUrl: string;
+    readonly description?: string;
+} | {
+    readonly type: "mutualTLS";
+    readonly description?: string;
+};
+/** The scheme an operation needs, and its scopes (none by default). */
+export interface SecurityRequirement {
+    readonly scheme: string;
+    readonly scopes?: readonly string[];
+}
+/**
+ * The options that route operations: shared by the `openapi` sink and the
+ * sinks that serve HTTP, so the served routes and the document agree.
+ */
+export interface RouteOptions {
+    /** Prefix of every path, e.g. `"/api"`. Empty by default. */
+    readonly basePath?: string;
+    /**
+     * Method, path and success status by operation id, e.g.
+     * `{ "Entries.get": { method: "get", path: "/entries/{slug}" } }`. A
+     * `{name}` segment of the path fills the scalar input key `name`.
+     */
+    readonly route?: {
+        readonly [operationId: string]: {
+            readonly method?: OpenAPIMethod;
+            readonly path?: string;
+            /** `200` by default. */
+            readonly status?: RouteStatus;
+        };
+    };
+    /** Static headers of the successful responses, by operation id. */
+    readonly responses?: {
+        readonly [operationId: string]: {
+            readonly headers?: {
+                readonly [name: string]: string;
+            };
+        };
+    };
+    /**
+     * Every response carries a request id: the one the request sent in this
+     * header, else a new UUID. `true` is `"x-request-id"`.
+     */
+    readonly requestId?: true | string;
+    /**
+     * Security schemes and the one each operation needs, for the document
+     * (`components.securitySchemes` and `security`). `default` applies to
+     * every operation not in `operations`; `false` there marks one public.
+     * Sinks that serve HTTP do not enforce it.
+     */
+    readonly security?: {
+        readonly schemes: {
+            readonly [name: string]: OpenAPISecurityScheme;
+        };
+        readonly operations?: {
+            readonly [operationId: string]: SecurityRequirement | false;
+        };
+        readonly default?: SecurityRequirement;
+    };
+}
 /** The options of the `openapi` sink. */
-export interface OpenAPISinkOptions {
+export interface OpenAPISinkOptions extends RouteOptions {
     readonly info: {
         readonly title: string;
         readonly version: string;
@@ -14,21 +99,15 @@ export interface OpenAPISinkOptions {
         readonly url: string;
         readonly description?: string;
     }[];
-    /** Prefix of every path, e.g. `"/api"`. Empty by default. */
-    readonly basePath?: string;
-    /** Method and path by operation id, e.g. `{ "Users.login": { path: "/session" } }`. */
-    readonly route?: {
-        readonly [operationId: string]: {
-            readonly method?: OpenAPIMethod;
-            readonly path?: string;
-        };
-    };
 }
 /** An OpenAPI 3.1 document. */
 export interface OpenAPIDocument {
     readonly openapi: "3.1.0";
     readonly info: OpenAPISinkOptions["info"];
     readonly servers?: OpenAPISinkOptions["servers"];
+    readonly security?: readonly {
+        readonly [scheme: string]: string[];
+    }[];
     readonly paths: {
         readonly [path: string]: Record<string, unknown>;
     };
@@ -36,30 +115,45 @@ export interface OpenAPIDocument {
         readonly schemas: {
             readonly [name: string]: OpenAPISchema;
         };
+        readonly securitySchemes?: {
+            readonly [name: string]: OpenAPISecurityScheme;
+        };
     };
 }
-/** The options that route operations: shared by the sinks that serve HTTP. */
-export interface RouteOptions {
-    readonly basePath?: string;
-    readonly route?: OpenAPISinkOptions["route"];
-}
-/** Where an operation is served. */
+/** The option names of {@link RouteOptions}, for sinks that list their options. */
+export declare const ROUTE_OPTION_KEYS: readonly ["basePath", "route", "responses", "requestId", "security"];
+/**
+ * Why the {@link RouteOptions} (`basePath`, `route`, `responses`,
+ * `requestId`, `security`) are not valid, naming them `where.<option>`;
+ * `undefined` when they are. Other keys of `options` are not looked at.
+ */
+export declare function routeOptionsIssue(options: RouteOptions, where: string): string | undefined;
+/**
+ * The header that carries the request id with these options (`"x-request-id"`
+ * for `requestId: true`), or `undefined` without `requestId`.
+ */
+export declare function requestIdHeaderOf(options: RouteOptions): string | undefined;
+/** Where an operation is served, and how it answers. */
 export interface OperationRoute {
     readonly method: OpenAPIMethod;
-    /** `basePath` included. */
+    /** `basePath` included, parameters as `{name}`. */
     readonly path: string;
+    /** The input keys the `{name}` segments of `path` fill, in order. */
+    readonly parameters: readonly string[];
+    /** The status of a success: `200` unless `route` says otherwise. */
+    readonly status: RouteStatus;
+    /** The static headers of a success, from `responses`. */
+    readonly headers: {
+        readonly [name: string]: string;
+    };
 }
 /**
- * Why `basePath` and `route` are not valid routing options, naming them
- * `where.basePath` and `where.route`; `undefined` when they are.
- */
-export declare function routeOptionsIssue(options: RouteOptions, where: string): string | undefined;
-/**
- * The route of every operation, by id: `POST {basePath}/{kebab(command)}/{kebab(operation)}`,
- * changed per operation id with `route`. Throws `InvalidOutputStage` (with
- * `source`) when `route` names an unknown operation or two operations share a
- * method and path. The routing of the `openapi` sink and of the sinks that
- * serve HTTP.
+ * The route of every operation, by id: `POST {basePath}/{kebab(command)}/{kebab(operation)}`
+ * with `200`, changed per operation id with `route` and `responses`. Throws
+ * `InvalidOutputStage` (with `source`) when `route`, `responses` or
+ * `security.operations` name an unknown operation, a path parameter is not a
+ * scalar key of the input, or two operations share a method and path. The
+ * routing of the `openapi` sink and of the sinks that serve HTTP.
  */
 export declare function operationRoutes(operations: readonly OperationDescriptor[], options: RouteOptions, source?: string): ReadonlyMap<string, OperationRoute>;
 /**
@@ -67,17 +161,23 @@ export declare function operationRoutes(operations: readonly OperationDescriptor
  *
  * Routes: `POST {basePath}/{kebab(command)}/{kebab(operation)}`, changed per
  * operation id with `route`; two operations on one method and path throw
- * `InvalidOutputStage`. The `operationId` is the id with its dot as an
- * underscore (`Users.register` -> `Users_register`), unique or the build
- * throws. `get` and `delete` send the input as query parameters, which needs
- * every input field to be a scalar property. Responses: `200` with the
- * response schema, `400` and `500` always, and the status of each declared
- * error (`statusOf`: `statuses` of the output, else 422). Operations carry no
- * repository dependencies, so `404` and `409` appear only when an error that
- * maps to them is declared. Records and entities reachable from inputs and
- * responses are named by class name in `components.schemas`, beside `Problem`
- * (RFC 9457). The `context` of an operation is transport-specific and not
- * part of the document; sinks that serve HTTP map it (headers, middleware).
+ * `InvalidOutputStage`. A `{name}` segment of a path is a required path
+ * parameter, the input key `name` (a scalar), left out of the body or query.
+ * The `operationId` is the id with its dot as an underscore (`Users.register`
+ * -> `Users_register`), unique or the build throws. `get` and `delete` send
+ * the input as query parameters, which needs every input field to be a
+ * scalar property. Responses: the `route` status (`200` by default; `204`
+ * without content) with the response schema and the `responses` headers,
+ * `400` and `500` always, and the status of each declared error (`statusOf`:
+ * `statuses` of the output, else 422); `requestId` adds its header to all of
+ * them. Operations carry no repository dependencies, so `404` and `409`
+ * appear only when an error that maps to them is declared. Records and
+ * entities reachable from inputs and responses are named by class name in
+ * `components.schemas`, beside `Problem` (RFC 9457). `security` gives
+ * `components.securitySchemes`, the document `security` (`default`) and the
+ * `security` of each operation. The `context` of an operation is
+ * transport-specific and not part of the document; sinks that serve HTTP map
+ * it (headers, middleware).
  */
 export declare const openapi: import("./types/output.interface.js").SinkFactory<OpenAPIDocument, OpenAPISinkOptions>;
 export {};

package/dist/core/output/status.d.ts

@@ -10,7 +10,7 @@ export declare function raisedOf(error: Exception): Exception;
  * The HTTP-style status of an error, in this order: `statuses` by exception
  * name; 400 for invalid input or context (and any exception whose
  * `details.issues` is a list, except `InvalidCommandEnvironment`, a 500); 404 for a missing entity or operation; 409 for
- * a unique violation or an entity that already exists; 401 for
+ * a unique violation, a concurrency conflict or an entity that already exists; 401 for
  * `UseCaseInvalidCredentials`; 422 for a class in `operation.errors`; 500 for the
  * rest, errors that are not exceptions included. Exceptions match by name,
  * or by class for `operation.errors`.

package/dist/core/parse/parse.d.ts

@@ -1,6 +1,16 @@
 import type { BlueprintField, IBlueprintCollection } from "../blueprint/types/blueprint.interface.js";
 import type { ParseResult } from "./types/parse.interface.js";
 type Path = readonly (string | number)[];
+/**
+ * `Object.entries(properties)`, kept for the next time.
+ * @internal
+ */
+export declare function fieldsOf(properties: IBlueprintCollection): readonly (readonly [string, BlueprintField])[];
+/**
+ * Whether `value` is an object made by `{}` or `Object.create(null)`, as parsed JSON is.
+ * @internal
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 /**
  * `value` handled by each field of `properties`, or every issue found: each
  * key `properties` does not declare, then those of each field, in order. Keys

package/dist/core/parse/strip.d.ts

@@ -0,0 +1,13 @@
+import type { AnyBlueprint, AnyRecordClass, BlueprintField } from "../blueprint/types/blueprint.interface.js";
+/**
+ * A copy of `value` without the keys `shape` does not declare, at any depth:
+ * in nested blueprints, the items of `listOf`, `optionalOf` and the records
+ * and entities held as fields. For a payload with more than the operation
+ * reads, such as a webhook from another service, before it is parsed, since
+ * parsing rejects an undeclared key (`undeclared_key`).
+ *
+ * It does not validate, never throws and does not change `value`: a value of
+ * the wrong type, a property's value (even an object) and a record instance
+ * come back as they are, for parsing to accept or reject.
+ */
+export declare function stripUndeclared(shape: AnyBlueprint | AnyRecordClass | BlueprintField, value: unknown): unknown;

package/dist/core/repository/exceptions.d.ts

@@ -24,7 +24,37 @@ export declare const InvalidRepositoryData: import("../../index.js").DeclaredExc
 export declare const RepositoryUniqueViolation: import("../../index.js").DeclaredExceptionClass<{
     readonly key: string;
 }>;
+/**
+ * A repository declared at module level was called after an application
+ * bound it to its provider: the calls of the application go through
+ * `app.repositories.<key>`, its use cases (`app.run`, `app.useCase`) or a
+ * repository given to `execute`; `source` is the repository name.
+ */
+export declare const RepositoryUsedOutsideApplication: import("../../index.js").DeclaredExceptionClass<{
+    readonly application: string;
+    readonly repository: string;
+}>;
 /** No entity of the id was found; `source` is the repository name. */
 export declare const RepositoryEntityNotFound: import("../../index.js").DeclaredExceptionClass<{
     readonly id: string;
 }>;
+/**
+ * `update` of a versioned entity found another version stored than the one
+ * it read: someone else wrote it in between (optimistic concurrency).
+ * `actual` is the stored version, when the provider knows it; `source` is the
+ * repository name. An output answers it with 409.
+ */
+export declare const RepositoryConcurrencyConflict: import("../../index.js").DeclaredExceptionClass<{
+    readonly id: string;
+    readonly expected: number;
+    readonly actual?: number;
+}>;
+/**
+ * `increment` got deltas it cannot apply: a key that is not a number in the
+ * `change` list of the entity, or a value that is not a finite number. Its
+ * `issues` name each, so an output answers it as invalid input.
+ */
+export declare const InvalidRepositoryIncrement: import("../../index.js").DeclaredExceptionClass<{
+    readonly reason: string;
+    readonly issues: readonly Issue[];
+}>;

package/dist/core/repository/in-memory.d.ts

@@ -1,4 +1,17 @@
 import type { IRepositoryProvider } from "./types/repository.interface.js";
+/**
+ * The provider of `inMemoryProvider`: it runs transactions, reads by cursor,
+ * honors expected versions, increments atomically and leaves expired records out.
+ */
+export type InMemoryProvider = IRepositoryProvider & {
+    readonly capabilities: {
+        readonly transactions: true;
+        readonly keyset: true;
+        readonly versioning: true;
+        readonly atomic: true;
+        readonly expiry: true;
+    };
+};
 /**
  * A provider that keeps the values in memory, one table per entity class,
  * enforcing its unique keys. Each `repositoryOf` without a provider gets its
@@ -7,4 +20,4 @@ import type { IRepositoryProvider } from "./types/repository.interface.js";
  * on rejection, runs one at a time and makes other operations wait; nested
  * transactions are savepoints.
  */
-export declare function inMemoryProvider(): IRepositoryProvider;
+export declare function inMemoryProvider(): InMemoryProvider;

package/dist/core/repository/plan.d.ts

@@ -0,0 +1,20 @@
+import type { RepositoryIndex, RepositoryOrder, RepositoryPlan } from "./types/query.interface.js";
+/** What the planner reads of a query: its conditions and its orders. */
+export interface PlannedQuery {
+    readonly where?: Readonly<Record<string, unknown>>;
+    readonly orderBy?: readonly RepositoryOrder[];
+}
+/** What the planner reads of a repository: its unique keys and its indexes. */
+export interface PlannedRepository {
+    readonly unique: readonly string[];
+    readonly indexes?: Readonly<Record<string, RepositoryIndex>>;
+}
+/**
+ * How `query` reaches its rows. A condition on `id`, or on another unique
+ * key, by equality or `in` (a batch of key lookups) gives `id` or `unique`.
+ * An index whose `where` keys all hold a condition by equality, and whose
+ * `orderBy` is the first order of the query (when it has one), gives
+ * `index`: the one with the most keys, the first declared on a tie. The rest
+ * is a `scan`. It reads nothing, and expects a query `prepareQuery` checked.
+ */
+export declare function planQuery(repository: PlannedRepository, query?: PlannedQuery): RepositoryPlan;

package/dist/core/repository/provider.d.ts

@@ -1,6 +1,6 @@
 import type { ProviderDescription, ProviderOptions, ProviderSettings } from "./types/query.interface.js";
 import type { IRepositoryProvider } from "./types/repository.interface.js";
 /** Creates a provider once and attaches an immutable, serializable declaration out of band. */
-export declare function providerOf<Options extends ProviderOptions = ProviderOptions, Provider extends IRepositoryProvider = IRepositoryProvider>(settings: ProviderSettings<Options, Provider>): Provider;
+export declare function providerOf<Options extends ProviderOptions = ProviderOptions, const Provider extends IRepositoryProvider = IRepositoryProvider>(settings: ProviderSettings<Options, Provider>): Provider;
 /** Describes a named provider; an anonymous one needs an explicit import on extraction. */
 export declare function providerDescriptionOf(provider: IRepositoryProvider): ProviderDescription;

package/dist/core/repository/query.d.ts

@@ -4,6 +4,13 @@ import type { RepositoryContext, RepositoryData } from "./types/repository.inter
 export declare function prepareQuery(context: RepositoryContext, input?: unknown, map?: (key: string, value: unknown) => unknown, options?: readonly string[]): RepositoryQuery;
 /** Structural JSON/data equality without depending on object key insertion order. */
 export declare function sameValue(a: unknown, b: unknown): boolean;
-export declare function matchesQuery(data: RepositoryData, query: RepositoryQuery): boolean;
+/** The time of `query.now`, or the current one. */
+export declare function nowOf(query: ProviderQuery): number;
+/**
+ * Whether `data` is a row of `query`: alive unless `withDeleted`, not expired
+ * by `expiry` (the key of `context.expiry`) unless `withExpired`, and matching
+ * `where`.
+ */
+export declare function matchesQuery(data: RepositoryData, query: ProviderQuery, expiry?: string, now?: number): boolean;
 /** The rows of `query` after ordering, `after`, offset and limit. */
-export declare function selectRows(rows: Iterable<RepositoryData>, query: ProviderQuery): RepositoryData[];
+export declare function selectRows(rows: Iterable<RepositoryData>, query: ProviderQuery, expiry?: string): RepositoryData[];

package/dist/core/repository/repository.d.ts

@@ -1,16 +1,24 @@
 import { type EnvironmentDependencies, type MergedEnvironment } from "../environment/environment.js";
 import { Kind } from "../symbols/kind.js";
-import type { AnyRepository, AnyRepositoryEntity, EntityInstanceOf, IRepositoryProvider, RepositoryAction, RepositoryContext, RepositoryData, RepositoryOf as RepositoryType } from "./types/repository.interface.js";
+import type { ProviderCapabilities, RepositoryIndex, RepositoryScans } from "./types/query.interface.js";
+import type { AnyRepository, AnyRepositoryEntity, EntityInstanceOf, EntityKeyOf, IRepositoryProvider, ProviderKeyset, RepositoryAction, RepositoryContext, RepositoryData, RepositoryOf as RepositoryType } from "./types/repository.interface.js";
 /** What `repositoryOf` takes. */
-export interface RepositorySettings<Entity extends AnyRepositoryEntity, Actions extends readonly RepositoryAction<Entity>[], Environment extends EnvironmentDependencies | undefined> {
+export interface RepositorySettings<Entity extends AnyRepositoryEntity, Actions extends readonly RepositoryAction<Entity>[], Environment extends EnvironmentDependencies | undefined, Capabilities extends ProviderCapabilities = ProviderCapabilities> {
     /** The entity class whose entities it holds. */
     readonly entity: Entity;
     /** Its methods, e.g. `["findById", "findByEmail", "findManyByName", "create"]`. */
     readonly actions: Actions;
     /** Physically remove rows (default), or retain them with `deletedAt`. */
     readonly deletion?: "hard" | "soft";
-    /** How it reads and writes; a new `inMemoryProvider()` by default. */
-    readonly provider?: IRepositoryProvider<MergedEnvironment<Environment>>;
+    /**
+     * How it reads and writes; a new `inMemoryProvider()` by default. When the
+     * type of its `capabilities.keyset` cannot be `true`, the repository has no
+     * `findCursor`. Only `capabilities` is inferred, so the methods of a
+     * provider written inline keep their parameter types.
+     */
+    readonly provider?: IRepositoryProvider<MergedEnvironment<Environment>> & {
+        readonly capabilities?: Capabilities;
+    };
     /** The environments the provider gets, merged, as `context.env`. */
     readonly environmentDependencies?: Environment;
     /**
@@ -19,7 +27,25 @@ export interface RepositorySettings<Entity extends AnyRepositoryEntity, Actions
      * loaded when read.
      */
     readonly relations?: readonly AnyRepository[];
+    /**
+     * Its access patterns, by name, e.g.
+     * `{ byTypeStatus: { where: ["type", "status"], orderBy: "publishedAt" } }`:
+     * a query that matches one reads through it, and the provider gets its
+     * name as `query.index` and every index as `context.indexes`.
+     */
+    readonly indexes?: Readonly<Record<string, RepositoryIndex<EntityKeyOf<Entity>>>>;
+    /**
+     * What a query only a scan serves does: runs (`"allow"`, the default),
+     * logs `repository-scan` and runs (`"warn"`), or throws
+     * `InvalidRepositoryQuery` (`"reject"`).
+     */
+    readonly scans?: RepositoryScans;
 }
+/**
+ * The repository `repositoryOf` gives: without `findCursor` when its provider
+ * cannot read by cursor (`Keyset` is `false`).
+ */
+type RepositoryOfProvider<Entity extends AnyRepositoryEntity, Actions extends readonly RepositoryAction<Entity>[], Environment, Keyset extends boolean> = Keyset extends true ? RepositoryType<Entity, Actions, Environment> : RepositoryType<Entity, Actions, Environment, false>;
 /**
  * A repository: the base of every class `repositoryOf` makes. Its methods are
  * the actions it was declared with; extend it, through `RepositoryOf`, to add
@@ -51,19 +77,24 @@ export declare abstract class AbstractRepository<Entity extends AnyRepositoryEnt
  * A repository of `entity` with the methods of `actions`: `findBy<Key>` for a
  * unique key (`id`, `options.unique`, a `unique` property), giving the entity
  * or `undefined`; `findManyBy<Key>` for any other key, giving a list;
- * `create`, `update`, `delete`, `restore` (soft deletion only), `count`, and the queries `findMany`,
- * `exists`, `findPage` and `findCursor`. Every method is async and reads and writes through `provider`
+ * `create`, `update`, `delete`, `restore` (soft deletion only), `increment`, `count`, and the queries `findMany`,
+ * `exists`, `findPage` and `findCursor`, and `forEachPage`, which walks the
+ * pages of a cursor query, resumably. Every method is async and reads and writes through `provider`
  * (a new `inMemoryProvider()` by default), which gets the variables of
  * `environmentDependencies` as `context.env`. The repository can be a
  * dependency of a use case, and `RepositoryOf` extends it with a class.
  */
-export declare function repositoryOf<Entity extends AnyRepositoryEntity, const Actions extends readonly RepositoryAction<Entity>[], const Environment extends EnvironmentDependencies | undefined = undefined>(settings: RepositorySettings<Entity, Actions, Environment>): RepositoryType<Entity, Actions, MergedEnvironment<Environment>>;
+export declare function repositoryOf<Entity extends AnyRepositoryEntity, const Actions extends readonly RepositoryAction<Entity>[], const Environment extends EnvironmentDependencies | undefined = undefined, const Capabilities extends ProviderCapabilities = {
+    readonly keyset: true;
+}>(settings: RepositorySettings<Entity, Actions, Environment, Capabilities>): RepositoryOfProvider<Entity, Actions, MergedEnvironment<Environment>, ProviderKeyset<{
+    readonly capabilities: Capabilities;
+}>>;
 /**
  * A repository of `Entity` with the methods of `Actions`, whose provider gets
  * `Environment` as `context.env`, e.g.
  * `RepositoryOf<typeof User, ["findById", "create"]>`.
  */
-export type RepositoryOf<Entity extends AnyRepositoryEntity, Actions extends readonly RepositoryAction<Entity>[], Environment = Readonly<Record<never, never>>> = RepositoryType<Entity, Actions, Environment>;
+export type RepositoryOf<Entity extends AnyRepositoryEntity, Actions extends readonly RepositoryAction<Entity>[], Environment = Readonly<Record<never, never>>, Keyset extends boolean = true> = RepositoryType<Entity, Actions, Environment, Keyset>;
 /**
  * The class of `repository`, to extend: its instances share the entity,
  * actions, provider and environment of `repository`, e.g.
@@ -73,3 +104,4 @@ export type RepositoryOf<Entity extends AnyRepositoryEntity, Actions extends rea
 export declare function RepositoryOf<Repository extends AnyRepository>(repository: Repository): new () => Repository;
 /** Whether `value` is a repository, made by `repositoryOf` or extending one. */
 export declare function isRepository(value: unknown): value is AnyRepository;
+export {};

package/dist/core/repository/state.d.ts

@@ -1,4 +1,6 @@
 import { type EnvironmentDependencies } from "../environment/environment.js";
+import type { ILogger } from "../logger/logger.js";
+import type { RepositoryIndex, RepositoryScans } from "./types/query.interface.js";
 import type { AnyRepositoryEntity, IRepositoryProvider, RepositoryContext } from "./types/repository.interface.js";
 /** What a repository class holds, shared by the classes extending it. */
 export interface RepositoryState {
@@ -12,6 +14,12 @@ export interface RepositoryState {
     readonly environment: EnvironmentDependencies | undefined;
     /** The repository of each entity class its entities hold, at any depth. */
     readonly relations: ReadonlyMap<object, RepositoryState>;
+    /** Its declared indexes, normalized and frozen. */
+    readonly indexes: Readonly<Record<string, RepositoryIndex>>;
+    /** What it does with a query only a scan serves. */
+    readonly scans: RepositoryScans;
+    /** The logger of the application that bound it, for `scans: "warn"`. */
+    readonly logger?: ILogger;
     context?: RepositoryContext;
 }
 export declare const states: WeakMap<object, RepositoryState>;
@@ -26,6 +34,8 @@ export interface RepositoryInspection {
     readonly entity: AnyRepositoryEntity;
     readonly actions: readonly string[];
     readonly deletion: "hard" | "soft";
+    readonly indexes: Readonly<Record<string, RepositoryIndex>>;
+    readonly scans: RepositoryScans;
     readonly explicitProvider: boolean;
     /** The provider, only when the repository declared it. */
     readonly provider: IRepositoryProvider | undefined;
@@ -46,9 +56,27 @@ export declare function declareRepository(state: RepositoryState, repository: ob
  * @internal
  */
 export declare function relatedRepositoryOf(repository: object, Entity: object): object | undefined;
+/**
+ * Throws `RepositoryUsedOutsideApplication` when `state` is a declaration an
+ * application bound to its provider: its calls would read another store.
+ */
+export declare function assertUnbound(state: RepositoryState): void;
+/** Where the application binding a repository comes from. */
+export interface RepositoryBinding {
+    /** The name of the application. */
+    readonly application: string;
+    /** The key of the repository in the application. */
+    readonly key: string;
+    /** The logger of the application, for `scans: "warn"`. */
+    readonly logger?: ILogger;
+}
 /**
  * A repository sharing the declaration of `repository` that reads and writes
  * through `provider`, unless it declared a provider of its own; a declared
- * provider found in `instances` is replaced by its value.
+ * provider found in `instances` is replaced by its value. With `binding`,
+ * the declaration (made by `repositoryOf`) throws
+ * `RepositoryUsedOutsideApplication` from then on.
  */
-export declare function bindRepository<Repository extends object>(repository: Repository, provider: IRepositoryProvider | undefined, instances?: ReadonlyMap<object, IRepositoryProvider>): Repository;
+export declare function bindRepository<Repository extends object>(repository: Repository, provider: IRepositoryProvider | undefined, instances?: ReadonlyMap<object, IRepositoryProvider>, binding?: RepositoryBinding): Repository;
+/** The provider `repository` reads and writes through. @internal */
+export declare function providerOfRepository(repository: unknown): IRepositoryProvider | undefined;