@tstdl/base 0.92.145 → 0.92.148

package/api/server/api-controller.d.ts

@@ -1,5 +1,5 @@
 import { type InjectableOptionsWithoutLifecycle } from '../../injector/decorators.js';
-import type { Constructor, Type } from '../../types.js';
+import type { Constructor, Type } from '../../types/index.js';
 import type { ApiController, ApiDefinition } from '../types.js';
 type ApiDefinitionProvider = () => ApiDefinition;
 export declare const apiControllerDefinition: unique symbol;

package/api/server/error-handler.d.ts

@@ -1,4 +1,4 @@
 import type { HttpServerResponse } from '../../http/server/index.js';
 import type { Logger } from '../../logger/index.js';
-import type { Type } from '../../types.js';
+import type { Type } from '../../types/index.js';
 export declare function handleApiError(error: unknown, response: HttpServerResponse, supressedErrors: Set<Type<Error>>, logger: Logger): HttpServerResponse;

package/api/server/gateway.d.ts

@@ -3,7 +3,7 @@ import type { HttpServerRequestContext } from '../../http/server/http-server.js'
 import { HttpServerResponse, type HttpServerRequest } from '../../http/server/index.js';
 import { resolveArgumentType, type Resolvable } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
-import type { Type } from '../../types.js';
+import type { Type } from '../../types/index.js';
 import { type AsyncMiddleware, type AsyncMiddlewareNext } from '../../utils/middleware.js';
 import { type ApiController, type ApiDefinition, type ApiEndpointDefinition, type ApiEndpointMethod, type ApiEndpointServerImplementation } from '../types.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
@@ -51,10 +51,6 @@ export type ApiMetadata = {
     api: ApiItem;
     patternResult: URLPatternResult;
 };
-/**
- * router for {@link ApiTransport} requests to {@link ApiImplementation}
- * @todo error handling (standardized format, serialization etc.)
- */
 export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
     private readonly requestTokenProvider;
     private readonly logger;

package/api/server/gateway.js

@@ -50,10 +50,6 @@ export class ApiGatewayOptions {
      */
     defaultMaxBytes;
 }
-/**
- * router for {@link ApiTransport} requests to {@link ApiImplementation}
- * @todo error handling (standardized format, serialization etc.)
- */
 let ApiGateway = class ApiGateway {
     requestTokenProvider;
     logger;

package/api/server/middlewares/catch-error.middleware.d.ts

@@ -1,4 +1,4 @@
 import type { Logger } from '../../../logger/index.js';
-import type { Type } from '../../../types.js';
+import type { Type } from '../../../types/index.js';
 import type { ApiGatewayMiddleware } from '../gateway.js';
 export declare function getCatchErrorMiddleware(supressedErrors: Set<Type<Error>>, logger: Logger): ApiGatewayMiddleware;

package/api/server/module.d.ts

@@ -1,4 +1,4 @@
-import type { Type } from '../../types.js';
+import type { Type } from '../../types/index.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
 import type { ApiGatewayOptions } from './gateway.js';
 export type ApiModuleOptions = {

package/api/types.d.ts

@@ -3,7 +3,7 @@ import type { HttpMethod } from '../http/types.js';
 import type { SchemaOutput, SchemaTestable } from '../schema/index.js';
 import type { ServerSentEventsSource } from '../sse/server-sent-events-source.js';
 import type { ServerSentEvents } from '../sse/server-sent-events.js';
-import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '../types.js';
+import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '../types/index.js';
 import { type ValueOrProvider } from '../utils/value-or-provider.js';
 import type { ApiGatewayMiddlewareContext } from './server/index.js';
 export type ApiRegistrationOptions = {

package/api/utils.d.ts

@@ -5,5 +5,6 @@ type GetApiEndpointUrlData = {
     defaultPrefix: string | undefined | null;
     explicitVersion?: number | null;
 };
+export declare const defaultAccessControlAllowHeaders = "Content-Type, Authorization";
 export declare function getFullApiEndpointResource({ api, endpoint, defaultPrefix, explicitVersion }: GetApiEndpointUrlData): string;
 export {};

package/api/utils.js

@@ -2,6 +2,7 @@ import { toArray } from '../utils/array/array.js';
 import { compareByValueDescending } from '../utils/comparison.js';
 import { sort } from '../utils/iterable-helpers/sort.js';
 import { isDefined, isNull } from '../utils/type-guards.js';
+export const defaultAccessControlAllowHeaders = 'Content-Type, Authorization';
 export function getFullApiEndpointResource({ api, endpoint, defaultPrefix, explicitVersion }) {
     const versionArray = toArray(isDefined(explicitVersion) ? explicitVersion : endpoint.version);
     const version = sort(versionArray, compareByValueDescending)[0];

package/application/application.d.ts

@@ -3,7 +3,7 @@ import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js'
 import type { LoggerArgument } from '../logger/index.js';
 import type { Module } from '../module/module.js';
 import type { FunctionModuleFunction } from '../module/modules/function.module.js';
-import type { OneOrMany, Type } from '../types.js';
+import type { OneOrMany, Type } from '../types/index.js';
 export type BootstrapFn = () => void | Promise<void>;
 export type RunOptions = {
     bootstrap?: OneOrMany<BootstrapFn>;

package/authentication/authentication.api.d.ts

@@ -1,13 +1,25 @@
 import { type ApiDefinition, type ApiEndpointsDefinition } from '../api/types.js';
 import { type ObjectSchema, type ObjectSchemaOrType } from '../schema/index.js';
 import type { SchemaTestable } from '../schema/schema.js';
-import type { Record } from '../types.js';
+import type { Record } from '../types/index.js';
 import type { TokenPayload } from './index.js';
 import { SecretCheckResult } from './models/secret-check-result.model.js';
+/**
+ * Can be provided in {@link ApiEndpointDefinition} data property to signal that the request does not need a valid token.
+ * Useful for login, refresh, etc. endpoints.
+ */
 export declare const dontWaitForValidToken: unique symbol;
 type GetAuthenticationApiEndpointsDefinition<AdditionalTokenPayload extends Record = Record<never>, AuthenticationData = void, AdditionalInitSecretResetData = void> = typeof getAuthenticationApiEndpointsDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>;
 type AuthenticationApiEndpointsDefinition<AdditionalTokenPayload extends Record = Record<never>, AuthenticationData = void, AdditionalInitSecretResetData = void> = ReturnType<GetAuthenticationApiEndpointsDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>>;
+/**
+ * Authentication REST API definition
+ *
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ */
 export type AuthenticationApiDefinition<AdditionalTokenPayload extends Record = Record<never>, AuthenticationData = void, AdditionalInitSecretResetData = void> = ApiDefinition<string, AuthenticationApiEndpointsDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>>;
+/** Default authentication API definition */
 export declare const authenticationApiDefinition: {
     resource: string;
     endpoints: {
@@ -103,6 +115,19 @@ export declare const authenticationApiDefinition: {
         };
     };
 };
+/**
+ * Get authentication REST API definition
+ * @param additionalTokenPayloadSchema Schema for additional token payload
+ * @param authenticationDataSchema Schema for additional authentication data
+ * @param initSecretResetDataSchema Schema for additional secret reset data
+ * @param resource Resource name (default: 'auth')
+ * @param additionalEndpoints Additional endpoints to add to the API definition
+ * @returns Authentication REST API definition
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ * @template AdditionalEndpoints Type of additional endpoints
+ */
 export declare function getAuthenticationApiDefinition<AdditionalTokenPayload extends Record, AuthenticationData, AdditionalInitSecretResetData, AdditionalEndpoints extends ApiEndpointsDefinition>(additionalTokenPayloadSchema: ObjectSchemaOrType<AdditionalTokenPayload>, authenticationDataSchema: SchemaTestable<AuthenticationData>, initSecretResetDataSchema: SchemaTestable<AdditionalInitSecretResetData>, resource?: string, additionalEndpoints?: AdditionalEndpoints): {
     resource: string;
     endpoints: {
@@ -198,6 +223,16 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
         };
     };
 };
+/**
+ * Get authentication REST API endpoints definition
+ * @param additionalTokenPayloadSchema Schema for additional token payload
+ * @param authenticationDataSchema Schema for additional authentication data
+ * @param additionalInitSecretResetDataSchema Schema for additional secret reset data
+ * @returns Authentication REST API endpoints definition
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ */
 export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenPayload extends Record, AuthenticationData, AdditionalInitSecretResetData>(additionalTokenPayloadSchema: ObjectSchemaOrType<AdditionalTokenPayload>, authenticationDataSchema: SchemaTestable<AuthenticationData>, additionalInitSecretResetDataSchema: SchemaTestable<AdditionalInitSecretResetData>): {
     getToken: {
         resource: string;

package/authentication/authentication.api.js

@@ -2,8 +2,26 @@ import { defineApi } from '../api/types.js';
 import { assign, emptyObjectSchema, explicitObject, literal, never, number, object, optional, string } from '../schema/index.js';
 import { SecretCheckResult } from './models/secret-check-result.model.js';
 import { TokenPayloadBase } from './models/token-payload-base.model.js';
+/**
+ * Can be provided in {@link ApiEndpointDefinition} data property to signal that the request does not need a valid token.
+ * Useful for login, refresh, etc. endpoints.
+ */
 export const dontWaitForValidToken = Symbol('dontWaitForValidToken');
+/** Default authentication API definition */
 export const authenticationApiDefinition = getAuthenticationApiDefinition(emptyObjectSchema, optional(never()), optional(never()));
+/**
+ * Get authentication REST API definition
+ * @param additionalTokenPayloadSchema Schema for additional token payload
+ * @param authenticationDataSchema Schema for additional authentication data
+ * @param initSecretResetDataSchema Schema for additional secret reset data
+ * @param resource Resource name (default: 'auth')
+ * @param additionalEndpoints Additional endpoints to add to the API definition
+ * @returns Authentication REST API definition
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ * @template AdditionalEndpoints Type of additional endpoints
+ */
 export function getAuthenticationApiDefinition(additionalTokenPayloadSchema, authenticationDataSchema, initSecretResetDataSchema, resource, additionalEndpoints) {
     return defineApi({
         resource: resource ?? 'auth',
@@ -13,6 +31,16 @@ export function getAuthenticationApiDefinition(additionalTokenPayloadSchema, aut
         },
     });
 }
+/**
+ * Get authentication REST API endpoints definition
+ * @param additionalTokenPayloadSchema Schema for additional token payload
+ * @param authenticationDataSchema Schema for additional authentication data
+ * @param additionalInitSecretResetDataSchema Schema for additional secret reset data
+ * @returns Authentication REST API endpoints definition
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ */
 export function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema, additionalInitSecretResetDataSchema) {
     const tokenResultSchema = assign(TokenPayloadBase, additionalTokenPayloadSchema);
     return {

package/authentication/client/api.client.d.ts

@@ -1,9 +1,22 @@
 import { type ApiClient } from '../../api/client/index.js';
 import { type ObjectSchemaOrType, type SchemaTestable } from '../../schema/index.js';
-import type { Record } from '../../types.js';
+import type { Record } from '../../types/index.js';
 import { type AuthenticationApiDefinition } from '../authentication.api.js';
+/**
+ * Get an authentication API client
+ * @param additionalTokenPayloadSchema Schema for additional token payload
+ * @param authenticationDataSchema Schema for additional authentication data
+ * @param additionalInitSecretResetData Schema for additional secret reset data
+ * @returns Authentication API client
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ */
 export declare function getAuthenticationApiClient<AdditionalTokenPayload extends Record, AuthenticationData, AdditionalInitSecretResetData>(additionalTokenPayloadSchema: ObjectSchemaOrType<AdditionalTokenPayload>, authenticationDataSchema: SchemaTestable<AuthenticationData>, additionalInitSecretResetData: SchemaTestable<AdditionalInitSecretResetData>): ApiClient<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>>;
 declare const defaultAuthenticationApiClient: ApiClient<AuthenticationApiDefinition<import("type-fest").EmptyObject, unknown, import("type-fest").EmptyObject>>;
+/**
+ * Default authentication API client
+ */
 export declare class AuthenticationApiClient extends defaultAuthenticationApiClient {
 }
 export {};

package/authentication/client/api.client.js

@@ -8,6 +8,16 @@ import { compileClient } from '../../api/client/index.js';
 import { ReplaceClass, Singleton } from '../../injector/index.js';
 import { emptyObjectSchema, unknown } from '../../schema/index.js';
 import { getAuthenticationApiDefinition } from '../authentication.api.js';
+/**
+ * Get an authentication API client
+ * @param additionalTokenPayloadSchema Schema for additional token payload
+ * @param authenticationDataSchema Schema for additional authentication data
+ * @param additionalInitSecretResetData Schema for additional secret reset data
+ * @returns Authentication API client
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ */
 export function getAuthenticationApiClient(additionalTokenPayloadSchema, authenticationDataSchema, additionalInitSecretResetData) {
     const definition = getAuthenticationApiDefinition(additionalTokenPayloadSchema, authenticationDataSchema, additionalInitSecretResetData);
     let AuthenticationApiClient = class AuthenticationApiClient extends compileClient(definition) {
@@ -18,6 +28,9 @@ export function getAuthenticationApiClient(additionalTokenPayloadSchema, authent
     return AuthenticationApiClient;
 }
 const defaultAuthenticationApiClient = getAuthenticationApiClient(emptyObjectSchema, unknown(), emptyObjectSchema);
+/**
+ * Default authentication API client
+ */
 let AuthenticationApiClient = class AuthenticationApiClient extends defaultAuthenticationApiClient {
 };
 AuthenticationApiClient = __decorate([

package/authentication/client/authentication.service.d.ts

@@ -2,8 +2,22 @@ import type { AsyncDisposable } from '../../disposable/index.js';
 import { disposeAsync } from '../../disposable/index.js';
 import type { AfterResolve } from '../../injector/index.js';
 import { afterResolve } from '../../injector/index.js';
-import type { Record } from '../../types.js';
+import type { Record } from '../../types/index.js';
 import type { SecretCheckResult, TokenPayload } from '../models/index.js';
+/**
+ * Handles authentication on client side.
+ *
+ * Can be used to:
+ * - Login/logout
+ * - Refresh token
+ * - Impersonate/unimpersonate
+ * - Reset secret
+ * - Check secret
+ *
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ */
 export declare class AuthenticationClientService<AdditionalTokenPayload extends Record = Record, AuthenticationData = any, AdditionalInitSecretResetData = void> implements AfterResolve, AsyncDisposable {
     private readonly client;
     private readonly errorSubject;
@@ -13,44 +27,133 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     private readonly lock;
     private readonly logger;
     private readonly disposeToken;
+    /**
+     * Observable for authentication errors.
+     * Emits when a refresh fails.
+     */
     readonly error$: import("rxjs").Observable<Error>;
+    /** Current token */
     readonly token: import("../../signals/api.js").WritableSignal<TokenPayload<AdditionalTokenPayload> | undefined>;
+    /** Whether the user is logged in */
     readonly isLoggedIn: import("../../signals/api.js").Signal<boolean>;
+    /** Current subject */
     readonly subject: import("../../signals/api.js").Signal<string | undefined>;
+    /** Current session id */
     readonly sessionId: import("../../signals/api.js").Signal<string | undefined>;
+    /** Current impersonator */
     readonly impersonator: import("../../signals/api.js").Signal<string | undefined>;
+    /** Whether the user is impersonated */
     readonly impersonated: import("../../signals/api.js").Signal<boolean>;
+    /** Current token */
     readonly token$: import("rxjs").Observable<TokenPayload<AdditionalTokenPayload> | undefined>;
+    /** Emits when token is available (not undefined) */
     readonly definedToken$: import("rxjs").Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;
+    /** Emits when a valid token is available (not undefined and not expired) */
     readonly validToken$: import("rxjs").Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;
+    /** Current subject */
     readonly subject$: import("rxjs").Observable<string | undefined>;
+    /** Emits when subject is available */
     readonly definedSubject$: import("rxjs").Observable<string>;
+    /** Current session id */
     readonly sessionId$: import("rxjs").Observable<string | undefined>;
+    /** Emits when session id is available */
     readonly definedSessionId$: import("rxjs").Observable<string>;
+    /** Whether the user is logged in */
     readonly isLoggedIn$: import("rxjs").Observable<boolean>;
+    /** Emits when the user logs out */
     readonly loggedOut$: import("rxjs").Observable<void>;
     private get authenticationData();
     private set authenticationData(value);
     private get impersonatorAuthenticationData();
     private set impersonatorAuthenticationData(value);
+    /**
+     * Get current token or throw if not available
+     * @throws Will throw if token is not available
+     */
     get definedToken(): TokenPayload<AdditionalTokenPayload>;
+    /**
+     * Get current subject or throw if not available
+     * @throws Will throw if subject is not available
+     */
     get definedSubject(): string;
+    /**
+     * Get current session id or throw if not available
+     * @throws Will throw if session id is not available
+     */
     get definedSessionId(): string;
+    /** Whether a valid token is available (not undefined and not expired) */
     get hasValidToken(): boolean;
     constructor(initialAuthenticationData: AuthenticationData | undefined);
+    /** @internal */
     [afterResolve](): void;
+    /**
+     * Initializes the service.
+     * Loads token from storage and starts refresh loop.
+     *
+     * @internal
+     */
     initialize(): void;
+    /** @internal */
     [disposeAsync](): Promise<void>;
+    /**
+     * Disposes the service.
+     * Stops refresh loop and completes subjects.
+     */
     dispose(): Promise<void>;
+    /**
+     * Set additional authentication data
+     * @param data The data to set
+     */
     setAdditionalData(data: AuthenticationData): void;
+    /**
+     * Login with subject and secret
+     * @param subject The subject to login with
+     * @param secret The secret to login with
+     * @param data Additional authentication data
+     */
     login(subject: string, secret: string, data?: AuthenticationData): Promise<void>;
+    /**
+     * Logout
+     */
     logout(): Promise<void>;
+    /**
+     * Force a refresh of the token
+     * @param data Additional authentication data
+     */
     requestRefresh(data?: AuthenticationData): void;
+    /**
+     * Refresh the token
+     * @param data Additional authentication data
+     */
     refresh(data?: AuthenticationData): Promise<void>;
+    /**
+     * Impersonate a subject
+     * @param subject The subject to impersonate
+     * @param data Additional authentication data
+     */
     impersonate(subject: string, data?: AuthenticationData): Promise<void>;
+    /**
+     * Unimpersonate
+     * @param data Additional authentication data. If not provided, the data from before impersonation is used.
+     */
     unimpersonate(data?: AuthenticationData): Promise<void>;
+    /**
+     * Initialize a secret reset
+     * @param subject The subject to reset the secret for
+     * @param data Additional data for secret reset
+     */
     initResetSecret(subject: string, data: AdditionalInitSecretResetData): Promise<void>;
+    /**
+     * Reset a secret
+     * @param token The secret reset token
+     * @param newSecret The new secret
+     */
     resetSecret(token: string, newSecret: string): Promise<void>;
+    /**
+     * Check a secret for requirements
+     * @param secret The secret to check
+     * @returns The result of the check
+     */
     checkSecret(secret: string): Promise<SecretCheckResult>;
     private saveToken;
     private loadToken;

package/authentication/client/authentication.service.js

@@ -35,6 +35,20 @@ const tokenUpdateBusName = 'AuthenticationService:tokenUpdate';
 const loggedOutBusName = 'AuthenticationService:loggedOut';
 const refreshLockResource = 'AuthenticationService:refresh';
 const localStorage = globalThis.localStorage;
+/**
+ * Handles authentication on client side.
+ *
+ * Can be used to:
+ * - Login/logout
+ * - Refresh token
+ * - Impersonate/unimpersonate
+ * - Reset secret
+ * - Check secret
+ *
+ * @template AdditionalTokenPayload Type of additional token payload
+ * @template AuthenticationData Type of additional authentication data
+ * @template AdditionalInitSecretResetData Type of additional secret reset data
+ */
 let AuthenticationClientService = class AuthenticationClientService {
     client = inject(AUTHENTICATION_API_CLIENT);
     errorSubject = new Subject();
@@ -44,21 +58,40 @@ let AuthenticationClientService = class AuthenticationClientService {
     lock = inject(Lock, refreshLockResource);
     logger = inject(Logger, 'AuthenticationService');
     disposeToken = new CancellationToken();
+    /**
+     * Observable for authentication errors.
+     * Emits when a refresh fails.
+     */
     error$ = this.errorSubject.asObservable();
+    /** Current token */
     token = signal(undefined);
+    /** Whether the user is logged in */
     isLoggedIn = computed(() => isDefined(this.token()));
+    /** Current subject */
     subject = computed(() => this.token()?.subject);
+    /** Current session id */
     sessionId = computed(() => this.token()?.sessionId);
+    /** Current impersonator */
     impersonator = computed(() => this.token()?.impersonator);
+    /** Whether the user is impersonated */
     impersonated = computed(() => isDefined(this.impersonator()));
+    /** Current token */
     token$ = toObservable(this.token);
+    /** Emits when token is available (not undefined) */
     definedToken$ = this.token$.pipe(filter(isDefined));
+    /** Emits when a valid token is available (not undefined and not expired) */
     validToken$ = this.definedToken$.pipe(filter((token) => token.exp > currentTimestampSeconds()));
+    /** Current subject */
     subject$ = toObservable(this.subject);
+    /** Emits when subject is available */
     definedSubject$ = this.subject$.pipe(filter(isDefined));
+    /** Current session id */
     sessionId$ = toObservable(this.sessionId);
+    /** Emits when session id is available */
     definedSessionId$ = this.sessionId$.pipe(filter(isDefined));
+    /** Whether the user is logged in */
     isLoggedIn$ = toObservable(this.isLoggedIn);
+    /** Emits when the user logs out */
     loggedOut$ = this.loggedOutBus.allMessages$;
     get authenticationData() {
         const data = localStorage?.getItem(authenticationDataStorageKey);
@@ -86,15 +119,28 @@ let AuthenticationClientService = class AuthenticationClientService {
             localStorage?.setItem(impersonatorAuthenticationDataStorageKey, json);
         }
     }
+    /**
+     * Get current token or throw if not available
+     * @throws Will throw if token is not available
+     */
     get definedToken() {
         return assertDefinedPass(this.token(), 'No token available.');
     }
+    /**
+     * Get current subject or throw if not available
+     * @throws Will throw if subject is not available
+     */
     get definedSubject() {
         return this.definedToken.subject;
     }
+    /**
+     * Get current session id or throw if not available
+     * @throws Will throw if session id is not available
+     */
     get definedSessionId() {
         return this.definedToken.sessionId;
     }
+    /** Whether a valid token is available (not undefined and not expired) */
     get hasValidToken() {
         return (this.token()?.exp ?? 0) > currentTimestampSeconds();
     }
@@ -103,26 +149,48 @@ let AuthenticationClientService = class AuthenticationClientService {
             this.authenticationData = initialAuthenticationData;
         }
     }
+    /** @internal */
     [afterResolve]() {
         this.initialize();
     }
+    /**
+     * Initializes the service.
+     * Loads token from storage and starts refresh loop.
+     *
+     * @internal
+     */
     initialize() {
         this.loadToken();
         this.tokenUpdateBus.messages$.subscribe((token) => this.token.set(token));
         void this.refreshLoop();
     }
+    /** @internal */
     async [disposeAsync]() {
         await this.dispose();
     }
+    /**
+     * Disposes the service.
+     * Stops refresh loop and completes subjects.
+     */
     async dispose() {
         this.disposeToken.set();
         this.errorSubject.complete();
         await this.loggedOutBus.dispose();
         await this.tokenUpdateBus.dispose();
     }
+    /**
+     * Set additional authentication data
+     * @param data The data to set
+     */
     setAdditionalData(data) {
         this.authenticationData = data;
     }
+    /**
+     * Login with subject and secret
+     * @param subject The subject to login with
+     * @param secret The secret to login with
+     * @param data Additional authentication data
+     */
     async login(subject, secret, data) {
         if (isDefined(data)) {
             this.setAdditionalData(data);
@@ -130,6 +198,9 @@ let AuthenticationClientService = class AuthenticationClientService {
         const token = await this.client.getToken({ subject, secret, data: this.authenticationData });
         this.setNewToken(token);
     }
+    /**
+     * Logout
+     */
     async logout() {
         try {
             await Promise.race([
@@ -142,12 +213,20 @@ let AuthenticationClientService = class AuthenticationClientService {
             this.loggedOutBus.publishAndForget();
         }
     }
+    /**
+     * Force a refresh of the token
+     * @param data Additional authentication data
+     */
     requestRefresh(data) {
         if (isDefined(data)) {
             this.setAdditionalData(data);
         }
         this.forceRefreshToken.set();
     }
+    /**
+     * Refresh the token
+     * @param data Additional authentication data
+     */
     async refresh(data) {
         if (isDefined(data)) {
             this.setAdditionalData(data);
@@ -161,6 +240,11 @@ let AuthenticationClientService = class AuthenticationClientService {
             throw error;
         }
     }
+    /**
+     * Impersonate a subject
+     * @param subject The subject to impersonate
+     * @param data Additional authentication data
+     */
     async impersonate(subject, data) {
         await this.lock.use(10000, true, async () => {
             this.impersonatorAuthenticationData = this.authenticationData;
@@ -175,6 +259,10 @@ let AuthenticationClientService = class AuthenticationClientService {
             }
         });
     }
+    /**
+     * Unimpersonate
+     * @param data Additional authentication data. If not provided, the data from before impersonation is used.
+     */
     async unimpersonate(data) {
         await this.lock.use(10000, true, async () => {
             const newData = data ?? this.impersonatorAuthenticationData;
@@ -190,12 +278,27 @@ let AuthenticationClientService = class AuthenticationClientService {
             }
         });
     }
+    /**
+     * Initialize a secret reset
+     * @param subject The subject to reset the secret for
+     * @param data Additional data for secret reset
+     */
     async initResetSecret(subject, data) {
         await this.client.initSecretReset({ subject, data });
     }
+    /**
+     * Reset a secret
+     * @param token The secret reset token
+     * @param newSecret The new secret
+     */
     async resetSecret(token, newSecret) {
         await this.client.resetSecret({ token, newSecret });
     }
+    /**
+     * Check a secret for requirements
+     * @param secret The secret to check
+     * @returns The result of the check
+     */
     async checkSecret(secret) {
         return await this.client.checkSecret({ secret });
     }

package/authentication/client/http-client.middleware.d.ts

@@ -1,4 +1,9 @@
 import type { HttpClientMiddleware } from '../../http/client/middleware.js';
 import { type ValueOrAsyncProvider } from '../../utils/value-or-provider.js';
 import type { AuthenticationClientService } from './authentication.service.js';
+/**
+ * A http client middleware that waits for a valid token before sending a request if the endpoint requires credentials.
+ * @param authenticationServiceOrProvider The authentication service or a provider for it.
+ * @returns A http client middleware.
+ */
 export declare function waitForAuthenticationCredentialsMiddleware(authenticationServiceOrProvider: ValueOrAsyncProvider<AuthenticationClientService>): HttpClientMiddleware;