@odx/auth 14.0.0 → 15.0.1

package/lib/auth.service.d.ts

@@ -3,6 +3,30 @@ import { AuthConfig, OAuthErrorEvent, TokenResponse } from 'angular-oauth2-oidc'
 import { Observable } from 'rxjs';
 import { AuthorizedHandler } from './models';
 import * as i0 from "@angular/core";
+/**
+ * The `AuthService` class provides authentication functionality for an Angular application.
+ * It handles OAuth2/OIDC authentication, token management, and user identity claims.
+ *
+ * Key responsibilities include:
+ * - Initializing authentication with a provided configuration.
+ * - Managing tokens (access, refresh, and ID tokens).
+ * - Checking and emitting authentication and authorization states.
+ * - Handling user login and logout flows.
+ * - Supporting silent refresh and offline authentication scenarios.
+ * - Integrating authentication plugins via `AuthPluginManager`.
+ *
+ * @example
+ * ```typescript
+ * // Injecting the AuthService
+ * constructor(private authService: AuthService) {}
+ *
+ * // Using the AuthService to initialize authentication
+ * async ngOnInit() {
+ *   const config: AuthConfig = { clientId: 'your-client-id', discoveryUrl: 'https://example.com/.well-known/openid-configuration' };
+ *   await this.authService.initialize(config);
+ * }
+ * ```
+ */
 export declare class AuthService {
     private readonly authConfig;
     private readonly authPluginManager;
@@ -14,29 +38,161 @@ export declare class AuthService {
     private readonly onAccessTokenUpdate$;
     private readonly silentRefreshHandler$;
     private readonly onAuthStateChange$;
+    /**
+     * Emits `true` when the service has completed initialization.
+     * Emits `false` until the initialization is complete.
+     *
+     * @type {Observable<boolean>}
+     */
     readonly isInitialized$: Observable<true>;
+    /**
+     * Emits `true` when the user is being redirected to the login page.
+     * Emits `false` when there is no redirection in progress.
+     *
+     * @type {Observable<boolean>}
+     */
     readonly isRedirecting$: Observable<boolean>;
+    /**
+     * Emits `true` when the application is in a loading state (e.g., during redirection or plugin initialization).
+     * Emits `false` when there is no ongoing loading activity.
+     *
+     * @type {Observable<boolean>}
+     */
     readonly isLoading$: Observable<boolean>;
+    /**
+     * Emits `true` when the user is authenticated.
+     * Emits `false` when the user is not authenticated.
+     *
+     * @type {Observable<boolean>}
+     */
     readonly isAuthenticated$: Observable<boolean>;
+    /**
+     * Emits the identity claims of the authenticated user.
+     * If the user is not authenticated, emits `null`.
+     *
+     * @type {Observable<OdxAuth.IdentityClaims | null>}
+     */
     readonly identityClaims$: Observable<OdxAuth.IdentiyClaims | null>;
+    /**
+     * Emits OAuth error events.
+     *
+     * @type {Observable<OAuthErrorEvent>}
+     */
     readonly errors$: Observable<OAuthErrorEvent>;
+    /**
+     * Emits events when an OAuth token is successfully received.
+     *
+     * @type {Observable<Event>}
+     */
     readonly onTokenReceived$: Observable<import("angular-oauth2-oidc").OAuthEvent>;
+    /**
+     * Emits whenever the `access_token` in local storage is updated or cleared.
+     * Provides an observable for tracking token updates.
+     *
+     * @type {Observable<StorageEvent | null>}
+     */
+    get accessTokenUpdate$(): Observable<StorageEvent | null>;
     constructor();
+    /**
+     * Initializes the authentication service with the provided configuration.
+     *
+     * @param {AuthConfig} config - The authentication configuration object.
+     * @returns {Promise<void>} Resolves when initialization is complete.
+     */
     initialize(config: AuthConfig): Promise<void>;
+    /**
+     * Runs all authentication plugins registered in the `AuthPluginManager`.
+     */
     runPlugins(): void;
+    /**
+     * Returns the issuer URL for the OAuth server.
+     *
+     * @returns {URL} The issuer URL.
+     */
     getIssuer(): URL;
+    /**
+     * Initiates the login flow for the user. Redirects to the login page.
+     *
+     * @param {string} [url] - The URL to redirect back to after login.
+     */
     signIn(url?: string): void;
+    /**
+     * Logs the user out and clears their tokens.
+     *
+     * @param {boolean} [noRedirect] - If `true`, no redirection occurs after logout.
+     */
     signOut(noRedirect?: boolean): void;
+    /**
+     * Attempts to refresh the user's tokens.
+     *
+     * @returns {Promise<TokenResponse>} Resolves with the new token response.
+     */
     refreshTokens(): Promise<TokenResponse>;
+    /**
+     * Retrieves the current access token, if available.
+     *
+     * @returns {string | null} The access token, or `null` if not available.
+     */
     getAccessToken(): string | null;
+    /**
+     * Retrieves the current refresh token, if available.
+     *
+     * @returns {string | null} The refresh token, or `null` if not available.
+     */
     getRefreshToken(): string | null;
+    /**
+     * Retrieves the current ID token, if available.
+     *
+     * @returns {string | null} The ID token, or `null` if not available.
+     */
     getIdToken(): string | null;
+    /**
+     * Retrieves the identity claims of the authenticated user.
+     *
+     * @returns {OdxAuth.IdentityClaims | null} The identity claims, or `null` if not available.
+     */
     getIdentityClaims(): OdxAuth.IdentiyClaims | null;
+    /**
+     * Retrieves the raw identity claims of the authenticated user.
+     *
+     * @returns {OdxAuth.RawIdentityClaims | null} The raw identity claims, or `null` if not available.
+     */
     getRawIdentityClaims(): OdxAuth.RawIdentityClaims | null;
+    /**
+     * Checks if the user is currently authenticated.
+     *
+     * @returns {boolean} `true` if authenticated, otherwise `false`.
+     */
     isAuthenticated(): boolean;
+    /**
+     * Checks if the user is authorized based on the provided handler.
+     *
+     * @param {AuthorizedHandler | null} [authorizedHandler] - A handler to determine authorization.
+     * @returns {boolean} `true` if authorized, otherwise `false`.
+     */
     isAuthorized(authorizedHandler?: AuthorizedHandler | null): boolean;
+    /**
+     * Emits whether the user is authorized based on the provided handler.
+     *
+     * @param {AuthorizedHandler | null} [authorizedHandler] - A handler to determine authorization.
+     * @returns {Observable<boolean>} An observable emitting the authorization status.
+     */
     isAuthorized$(authorizedHandler?: AuthorizedHandler | null): Observable<boolean>;
+    /**
+     * Prepares an HTTP request by adding the access token to its headers.
+     *
+     * @param {HttpRequest<T> | Request} req - The HTTP request to prepare.
+     * @param {boolean} requireSignIn - Whether to require the user to sign in if no token is available.
+     * @returns {Observable<R>} An observable emitting the prepared request.
+     * @template R, T
+     */
     prepareAuthRequest$<R extends HttpRequest<T> | Request, T>(req: R, requireSignIn?: boolean): Observable<R>;
+    /**
+     * Waits for a valid access token to become available.
+     *
+     * @param {boolean} requireSignIn - Whether to require the user to sign in if no token is available.
+     * @returns {Observable<string | null>} An observable emitting the access token.
+     */
     waitForAccessToken$(requireSignIn: boolean): Observable<string | null>;
     private routeToRequestedUrl;
     private hasValidOfflineToken;

package/lib/components/auth-actions/auth-actions.component.d.ts

@@ -1,6 +1,15 @@
 import * as i0 from "@angular/core";
+/**
+ * Displays authentication actions.
+ */
 export declare class AuthActionsComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The identity claims.
+     *
+     * @type {OdxAuth.IdentiyClaims | null}
+     * @default null
+     */
     claims: OdxAuth.IdentiyClaims | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<AuthActionsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AuthActionsComponent, "odx-auth-actions", never, { "claims": { "alias": "claims"; "required": false; }; }, {}, never, never, true, never>;

package/lib/components/auth-loading-screen/auth-loading-screen.component.d.ts

@@ -1,10 +1,23 @@
 import { DynamicViewService } from '@odx/angular/cdk/dynamic-view';
 import { AuthService } from '../../auth.service';
 import * as i0 from "@angular/core";
+/**
+ * Authentication loading screen.
+ *
+ * This component displays a loading screen with animations and dynamic content
+ * based on the authentication state.
+ */
 export declare class AuthLoadingScreenComponent {
     private static instance;
     protected readonly authConfig: import("../../auth.config").AuthConfig;
     protected readonly icon$: import("rxjs").Observable<"link-external" | "user">;
+    /**
+     * Initializes the authentication loading screen.
+     *
+     * @param {AuthService} authService - The authentication service.
+     * @param {DynamicViewService} dynamicViewService - The dynamic view service used to create the loading screen.
+     * @static
+     */
     static initialize(authService: AuthService, dynamicViewService: DynamicViewService): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AuthLoadingScreenComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AuthLoadingScreenComponent, "div.odx-auth-loading-screen", never, {}, {}, never, never, true, never>;

package/lib/directives/auth-action.directive.d.ts

@@ -1,6 +1,12 @@
 import { AfterViewInit } from '@angular/core';
 import { AuthService } from '../auth.service';
 import * as i0 from "@angular/core";
+/**
+ * An abstract directive that integrates with the `LoadingSpinnerDirective` and `AuthService` to manage loading states based on authentication redirection.
+ *
+ * This directive automatically sets the `autoColor` property of the `LoadingSpinnerDirective` to `true` and subscribes to the `isRedirecting$` observable from the `AuthService`.
+ * When `isRedirecting$` emits a value, it updates the `isLoading` property of the `LoadingSpinnerDirective`.
+ */
 export declare abstract class AuthActionDirective implements AfterViewInit {
     private readonly takeUntilDestroyed;
     private readonly loadingSpinnerDirective;

package/lib/directives/sign-in.directive.d.ts

@@ -1,8 +1,27 @@
+/**
+ * A directive that handles the sign-in action for a button element.
+ *
+ * This directive extends the `AuthActionDirective` and uses the `LoadingSpinnerDirective`
+ * to show a loading spinner during the sign-in process.
+ *
+ * @see {AuthActionDirective}
+ * @see {LoadingSpinnerDirective}
+ *
+ * @example
+ * ```html
+ * <button odxButton odxAuthSignIn (odxAuthSignIn)="onSignIn()">Sign In</button>
+ * ```
+ */
 import { EventEmitter } from '@angular/core';
 import { AuthActionDirective } from './auth-action.directive';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/components/loading-spinner";
 export declare class SignInDirective extends AuthActionDirective {
+    /**
+     * Emits an event after the sign-in action is completed.
+     *
+     * @type {EventEmitter<void>}
+     */
     afterSignIn: EventEmitter<void>;
     protected handleClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SignInDirective, never>;

package/lib/directives/sign-out.directive.d.ts

@@ -2,7 +2,26 @@ import { EventEmitter } from '@angular/core';
 import { AuthActionDirective } from './auth-action.directive';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/components/loading-spinner";
+/**
+ * A directive that handles the sign-out action for a button element.
+ *
+ * This directive extends the `AuthActionDirective` and uses the `LoadingSpinnerDirective`
+ * to show a loading spinner during the sign-out process.
+ *
+ * @see {AuthActionDirective}
+ * @see {LoadingSpinnerDirective}
+ *
+ * @example
+ * ```html
+ * <button odxButton odxAuthSignOut (odxAuthSignOut)="onSignOut()">Sign Out</button>
+ * ```
+ */
 export declare class SignOutDirective extends AuthActionDirective {
+    /**
+     * Emits an event after the sign-out action is completed.
+     *
+     * @type {EventEmitter<void>}
+     */
     afterSignOut: EventEmitter<void>;
     protected handleClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SignOutDirective, never>;

package/lib/helpers/create-auth-host-url.d.ts

@@ -1,2 +1,14 @@
 import { AuthEnvironment } from '../models';
+/**
+ * Creates an authentication host URL based on the provided environment and URL segments.
+ *
+ * @param {AuthEnvironment} environment - The authentication environment (e.g., 'development', 'production').
+ * @param {string[]} segments - Additional URL segments to append to the base URL.
+ * @returns {string} The constructed authentication host URL.
+ *
+ * @example
+ * ```ts
+ * createAuthHostUrl('dev', 'api', 'v1', 'users'); // returns 'https://dev-auth.odx.com/api/v1/users'
+ * ```
+ */
 export declare function createAuthHostUrl(environment: AuthEnvironment, ...segments: string[]): string;

package/lib/helpers/create-inititals.d.ts

@@ -1 +1,18 @@
+/**
+ * Creates initials from a given string.
+ *
+ * This function takes a string input, removes any text within parentheses,
+ * trims any leading or trailing whitespace, and then splits the string into
+ * parts based on spaces. It then constructs initials using the first letter
+ * of the first and last parts of the string, converting them to uppercase.
+ *
+ * @param {string | null} value - The input string from which to create initials. It can be
+ *                undefined or null, in which case an empty string is returned.
+ * @returns {string} - A string containing the initials derived from the input string.
+ *
+ * @example
+ * ```ts
+ * createInitials('John Smith'); // returns 'JS'
+ * ```
+ */
 export declare function createInitials(value?: string | null): string;

package/lib/helpers/handle-auth-error.d.ts

@@ -1,3 +1,13 @@
 import { OAuthErrorEvent } from 'angular-oauth2-oidc';
 import { AuthErrorHandlerFn } from '../auth.config';
+/**
+ * Handles authentication errors by executing a series of error handler functions.
+ *
+ * @param {AuthErrorHandlerFn[]} handlers - An array of functions that handle authentication errors.
+ * Each function is expected to take an `OAuthErrorEvent` as an argument.
+ *
+ * @returns A function that takes an `OAuthErrorEvent` and processes it using the provided handlers.
+ * The function will stop processing once a handler successfully handles the error without throwing.
+ * If a handler throws an error that is not an instance of `OAuthErrorEvent`, the original error is re-thrown.
+ */
 export declare function handleAuthError(handlers: AuthErrorHandlerFn[]): (error: OAuthErrorEvent) => void;

package/lib/helpers/handle-oauth-event.d.ts

@@ -1,3 +1,11 @@
 import { OAuthEvent } from 'angular-oauth2-oidc';
 import { OperatorFunction } from 'rxjs';
+/**
+ * Handles OAuth events of a specific type by applying a provided handler function.
+ *
+ * @template {T} - The type of OAuth event.
+ * @param {T['type']} type - The type of the OAuth event to handle.
+ * @param {(event: T) => Promise<void>} handler - A function that takes an event of type T and returns a Promise that resolves to void.
+ * @returns {OperatorFunction<T, void>} - An OperatorFunction that filters events of the specified type and applies the handler function.
+ */
 export declare function handleOAuthEvent<T extends OAuthEvent>(type: T['type'], handler: (event: T) => Promise<void>): OperatorFunction<T, void>;

package/lib/helpers/resolve-email.d.ts

@@ -1 +1,21 @@
+/**
+ * Resolves the email address from the given identity claims.
+ *
+ * This function attempts to extract an email address from the provided
+ * `OdxAuth.RawIdentityClaims` object by checking the following properties
+ * in order:
+ * 1. `email` - if it is a string, it is returned.
+ * 2. `email_address` - if it is a string, it is returned.
+ * 3. `emails` - if it is an array and the first element is a string, the first element is returned.
+ *
+ * If none of these properties contain a valid string email address, an empty string is returned.
+ *
+ * @param {OdxAuth.RawIdentityClaims} claims - The identity claims object from which to resolve the email address.
+ * @returns {string} - The resolved email address as a string, or an empty string if no valid email address is found.
+ *
+ * @example
+ * ```ts
+ * resolveEmail({ email_address: 'email.address@mdn.com' }) // returns 'email.address@mdn.com';
+ * ```
+ */
 export declare function resolveEmail(claims: OdxAuth.RawIdentityClaims): string;

package/lib/helpers/resolve-username.d.ts

@@ -1 +1,22 @@
+/**
+ * Resolves the username from the provided identity claims.
+ *
+ * The function attempts to construct a username from the claims in the following order:
+ * 1. If both 'firstname' and 'lastname' are strings, it returns them concatenated with a space.
+ * 2. If both 'given_name' and 'family_name' are strings, it returns them concatenated with a space.
+ * 3. If 'name' is a string, it returns the 'name'.
+ * 4. If 'displayname' is a string, it returns the 'displayname'.
+ * 5. If none of the above conditions are met, it returns an empty string.
+ *
+ * @param {OdxAuth.RawIdentityClaims} claims - The raw identity claims from which to resolve the username.
+ * @returns {string} - The resolved username as a string.
+ *
+ * @example
+ * ```ts
+ * resolveUsername({ firstname: 'John', lastname: 'Doe' }) // returns 'John Doe';
+ * resolveUsername({ given_name: 'John', family_name: 'Doe' }) // returns 'John Doe';
+ * resolveUsername({ name: 'John Doe' }) // returns 'John Doe';
+ * resolveUsername({ displayname: 'John Doe' }) // returns 'John Doe';
+ * ```
+ */
 export declare function resolveUsername(claims: OdxAuth.RawIdentityClaims): string;

package/lib/helpers/set-http-auth-header.d.ts

@@ -1,2 +1,11 @@
 import { HttpRequest } from '@angular/common/http';
+/**
+ * Sets the HTTP Authorization header for a given request.
+ *
+ * @template R - The type of the request, which extends HttpRequest<T> or Request.
+ * @template T - The type of the request body.
+ * @param {R} req - The HTTP request to which the Authorization header will be added.
+ * @param {string | null} [token] - The token to be used in the Authorization header. If no token is provided, the request is returned unchanged.
+ * @returns {R} - The modified HTTP request with the Authorization header set, or the original request if no token is provided.
+ */
 export declare function setHttpAuthHeader<R extends HttpRequest<T> | Request, T>(req: R, token?: string | null): R;

package/lib/helpers/user-language-loader.d.ts

@@ -1,4 +1,11 @@
 import { LanguageLoaderFn } from '@odx/angular/localization';
 type LanguageSelector = (claims?: OdxAuth.IdentiyClaims | null) => string | null | undefined;
+/**
+ * A function that creates a language loader function for user authentication.
+ *
+ * @param {LanguageSelector} languageSelector - A function that takes optional identity claims and returns a language string, null, or undefined.
+ *                           Defaults to a function that returns the preferred language from the claims.
+ * @returns {LanguageLoaderFn} - A function that retrieves the user's preferred language from the identity claims.
+ */
 export declare function userLanguageLoader(languageSelector?: LanguageSelector): LanguageLoaderFn;
 export {};

package/lib/plugins/core-debug.plugin.d.ts

@@ -1,2 +1,11 @@
 import { AuthPluginFactory } from '../models';
+/**
+ * A factory function that creates a core debug plugin for the authentication service.
+ * This plugin logs detailed information about the user's identity claims and tokens.
+ *
+ * @remarks
+ * This plugin is intended for debugging purposes only and should not be used in production environments.
+ *
+ * @returns {AuthPluginFactory} A function that takes an authentication service and sets up logging for identity claims and tokens.
+ */
 export declare const coreDebugPlugin: AuthPluginFactory;

package/lib/plugins/core-identity.plugin.d.ts

@@ -8,4 +8,11 @@ declare global {
         }
     }
 }
+/**
+ * Core identity plugin for authentication.
+ *
+ * This plugin extracts and processes identity claims from the authentication service.
+ *
+ * @returns {AuthPluginFactory} A factory function that returns an observable with the processed identity claims.
+ */
 export declare const coreIdentityPlugin: AuthPluginFactory;

package/lib/plugins/user-profile-link.plugin.d.ts

@@ -6,4 +6,13 @@ declare global {
         }
     }
 }
+/**
+ * A plugin factory that generates a user profile URL plugin.
+ *
+ * This plugin retrieves the user profile URL from the authentication configuration.
+ * If the user profile URL is not specified in the configuration, it falls back to
+ * using the default URL for the current environment from `ODX_AUTH_USER_PROFILE_HOSTS`.
+ *
+ * @returns A function that returns an observable emitting an object containing the user profile URL.
+ */
 export declare const userProfileUrlPlugin: AuthPluginFactory;

package/lib/unauth.guard.d.ts

@@ -1,3 +1,11 @@
 import { CanActivateFn } from '@angular/router';
 import { AuthorizedHandler } from './models';
+/**
+ * Guard function to prevent unauthorized access to routes.
+ *
+ * @param {AuthorizedHandler} authorizedHandler - Optional handler to check if the user is authorized.
+ * @param {any[] | string} redirectTo - Optional URL or route to redirect unauthorized users to. Can be a string or an array of strings.
+ * @param {boolean} isExternal - Optional flag to indicate if the redirection should be external. Defaults to false.
+ * @returns {CanActivateFn} - A function that implements the CanActivateFn interface.
+ */
 export declare function unauthGuard(authorizedHandler?: AuthorizedHandler, redirectTo?: any[] | string, isExternal?: boolean): CanActivateFn;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@odx/auth",
-  "version": "14.0.0",
+  "version": "15.0.1",
   "author": "Drägerwerk AG & Co.KGaA",
   "license": "SEE LICENSE IN LICENSE",
   "peerDependencies": {
-    "@odx/angular": "^11.0.0"
+    "@odx/angular": "^12.0.0"
   },
   "dependencies": {
     "angular-oauth2-oidc": "^15.0.1",

package/plugins/service-connect/lib/helpers/build-service-connect-url.d.ts

@@ -1,3 +1,10 @@
 import { AuthEnvironment } from '@odx/auth';
 import { ServiceConnectEnvironment } from '../service-connect.config';
+/**
+ * Builds a service connect URL based on the provided environment and endpoints.
+ *
+ * @param {ServiceConnectEnvironment | AuthEnvironment} environment - The environment configuration which can be either a `ServiceConnectEnvironment` or `AuthEnvironment`.
+ * @param {string[]} endpoints - A list of endpoint strings to be appended to the base URL.
+ * @returns {string} - The constructed service connect URL as a string.
+ */
 export declare function buildServiceConnectUrl(environment: ServiceConnectEnvironment | AuthEnvironment, ...endpoints: string[]): string;

package/plugins/service-connect/lib/helpers/has-roles-or-rights-handler.d.ts

@@ -1,3 +1,10 @@
 import { AuthorizedHandler } from '@odx/auth';
 import { RolesOrRights } from './has-roles-or-rights';
+/**
+ * Creates an authorized handler that checks if the user has the specified roles or rights.
+ *
+ * @param {RolesOrRights} rolesOrRights - The roles or rights to check against the user's claims.
+ * @returns {AuthorizedHandler} - An handler function that takes user claims and returns a boolean indicating
+ *          whether the user has the required roles or rights.
+ */
 export declare function hasRolesOrRightsHandler(rolesOrRights: RolesOrRights): AuthorizedHandler;

package/plugins/service-connect/lib/helpers/has-roles-or-rights.d.ts

@@ -1,4 +1,11 @@
 export type Right = string | number;
 export type Role = Right[];
 export type RolesOrRights = Array<Role | Right>;
+/**
+ * Checks if the user has any of the specified roles or rights.
+ *
+ * @param {Right[]} userRights - An array of rights that the user possesses.
+ * @param {RolesOrRights} rolesOrRights - An array of roles or rights to check against. A role is represented as an array of rights.
+ * @returns {boolean} - `true` if the user has any of the specified roles or rights, otherwise `false`.
+ */
 export declare function hasRolesOrRights(userRights: Right[], rolesOrRights: RolesOrRights): boolean;

package/plugins/service-connect/lib/helpers/service-connect-plugin-factory.d.ts

@@ -10,4 +10,10 @@ export interface ServiceConnectPluginFactoryOptions<Dto> {
     setup?: (pluginOptions?: ServiceConnectPluginOptions) => void;
 }
 export type ServiceConnectPluginFactory = (pluginOptions?: ServiceConnectPluginOptions) => AuthPluginFactory;
+/**
+ * Creates a plugin factory for fetching and parsing service connect data.
+ *
+ * @param {ServiceConnectPluginFactoryOptions<Dto>} options - The options for the service connect plugin factory.
+ * @returns {ServiceConnectPluginFactory} - A function that creates an auth plugin factory for fetching and parsing service connect data.
+ */
 export declare function serviceConnectPluginFactory<Dto = unknown>(options: ServiceConnectPluginFactoryOptions<Dto>): ServiceConnectPluginFactory;

package/plugins/service-connect/lib/service-connect-rights.directive.d.ts

@@ -1,8 +1,20 @@
 import { RolesOrRights } from './helpers';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/auth";
+/**
+ * A directive that extends the functionality of the `AuthDirective` to handle
+ * roles or rights for service connection authorization.
+ *
+ * @see AuthDirective
+ *
+ * This directive should be used on an `ng-template` element with the selector
+ * `odxAuthServiceConnectRights`.
+ */
 export declare class ServiceConnectRightsDirective {
     private readonly authDirective;
+    /**
+     * Sets the roles or rights that the user must have to display the content.
+     */
     set rolesOrRights(value: RolesOrRights | null | undefined);
     static ɵfac: i0.ɵɵFactoryDeclaration<ServiceConnectRightsDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ServiceConnectRightsDirective, "ng-template[odxAuthServiceConnectRights]", never, { "rolesOrRights": { "alias": "odxAuthServiceConnectRights"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.AuthDirective; inputs: { "odxAuthElse": "odxAuthServiceConnectRightsElse"; }; outputs: {}; }]>;

package/plugins/service-connect/lib/service-connect-rights.guard.d.ts

@@ -1,3 +1,11 @@
 import { CanActivateFn } from '@angular/router';
 import { RolesOrRights } from './helpers';
+/**
+ * A guard function to check if the user has the required roles or rights to access a route.
+ *
+ * @param {RolesOrRights} rolesOrRights - The roles or rights required to access the route.
+ * @param {string | any[]} redirectTo - (Optional) The route to redirect to if the user does not have the required roles or rights.
+ * @param {boolean} isExternal - (Optional) A flag indicating if the redirection is to an external URL. Defaults to `false`.
+ * @returns {CanActivateFn} - A function that checks the user's roles or rights and handles redirection if necessary.
+ */
 export declare function serviceConnectRightsGuard(rolesOrRights: RolesOrRights, redirectTo?: string | any[], isExternal?: boolean): CanActivateFn;

package/plugins/service-connect/lib/service-connect-rights.plugin.d.ts

@@ -6,4 +6,12 @@ declare global {
         }
     }
 }
+/**
+ * A plugin for fetching and parsing service connect rights.
+ *
+ * This plugin uses the `serviceConnectPluginFactory` to create a plugin that fetches user rights
+ * from the specified endpoint and parses the response to extract the rights.
+ *
+ * @see {serviceConnectPluginFactory}
+ */
 export declare const serviceConnectRightsPlugin: import("./helpers").ServiceConnectPluginFactory;

package/plugins/service-connect/lib/service-connect-user-language.plugin.d.ts

@@ -1,3 +1,17 @@
 import { GetServiceConnectUserResponseDto } from './dtos';
+/**
+ * Gets the language code from a service connect user response.
+ *
+ * @param {GetServiceConnectUserResponseDto | null} res - The service connect user response.
+ * @returns {string | undefined} - The language code or undefined.
+ */
 export declare function getServiceConnectUserLanguage(res?: GetServiceConnectUserResponseDto | null): string | undefined;
+/**
+ * A plugin for fetching and parsing the user's preferred language from service connect.
+ *
+ * This plugin uses the `serviceConnectPluginFactory` to create a plugin that fetches the user's preferred language
+ * from the user endpoint and parses the response to extract the preferred language.
+ *
+ * @see {serviceConnectPluginFactory}
+ */
 export declare const serviceConnectUserLanguagePlugin: import("./helpers").ServiceConnectPluginFactory;

package/plugins/service-connect/lib/service-connect-user-profile.plugin.d.ts

@@ -8,4 +8,12 @@ declare global {
         }
     }
 }
+/**
+ * A plugin for fetching and parsing the user's profile from service connect.
+ *
+ * This plugin uses the `serviceConnectPluginFactory` to create a plugin that fetches the user's profile
+ * from the user endpoint and parses the response to extract the user's profile information.
+ *
+ * @see {serviceConnectPluginFactory}
+ */
 export declare const serviceConnectUserProfilePlugin: import("./helpers").ServiceConnectPluginFactory;