@equinor/fusion-framework-module-services 7.2.1 → 8.0.0

package/dist/types/bookmarks/api-version.d.ts

@@ -1,4 +1,7 @@
+/** Supported API versions for the bookmarks service. */
 export declare enum ApiVersion {
+    /** Bookmarks API version 1.0. */
     v1 = "1.0",
+    /** Bookmarks API version 2.0. */
     v2 = "2.0"
 }

package/dist/types/bookmarks/index.d.ts

@@ -1,3 +1,16 @@
+/**
+ * @packageDocumentation
+ *
+ * Bookmarks API client and types.
+ *
+ * Provides {@link BookmarksApiClient} for CRUD operations on bookmarks
+ * and favourite management, with versioned endpoints (`v1`, `v2`).
+ *
+ * @example
+ * ```ts
+ * import { BookmarksApiClient } from '@equinor/fusion-framework-module-services/bookmarks';
+ * ```
+ */
 export { BookmarksApiClient, default } from './client';
 export { ApiVersion } from './api-version';
 export * from './schemas';

package/dist/types/bookmarks/schemas.d.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
+/** Zod schema that parses an ISO-8601 datetime string into a `Date` object. */
 export declare const ApiDateSchema: z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>;
+/** Zod schema for a person reference in a bookmark response. */
 export declare const ApiPersonSchema: {
     "1.0": z.ZodObject<{
         azureUniqueId: z.ZodString;
@@ -21,6 +23,7 @@ export declare const ApiPersonSchema: {
         }>>>;
     }, z.core.$strip>;
 };
+/** Zod schema for the source system of a bookmark. */
 export declare const ApiSourceSystem: {
     "1.0": z.ZodObject<{
         identifier: z.ZodString;
@@ -28,6 +31,7 @@ export declare const ApiSourceSystem: {
         subSystem: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
 };
+/** Zod schema for a Fusion context reference attached to a bookmark. */
 export declare const ApiFusionContext: {
     "1.0": z.ZodObject<{
         id: z.ZodString;
@@ -156,6 +160,12 @@ export declare const ApiBookmarkSchema: {
         }, z.core.$strip>>>;
     }, z.core.$strip>;
 };
+/**
+ * Zod schema for the bookmark payload.
+ *
+ * Accepts a record of key-value pairs, a JSON string, or `undefined`.
+ * JSON strings are automatically parsed into objects.
+ */
 export declare const ApiBookmarkPayload: {
     readonly "1.0": z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>>, z.ZodTransform<any, string | Record<string, unknown>>>;
 };

package/dist/types/bookmarks/types.d.ts

@@ -1,5 +1,22 @@
+/**
+ * Re-exported shared types scoped for the bookmarks service.
+ *
+ * @packageDocumentation
+ */
 import type { FilterAllowedApiVersions as FilterAllowApiVersionsBase, ExtractApiVersion as ExtractApiVersionBase } from '../types';
 import type { ApiVersion } from './api-version';
 export { ClientMethodType, ClientMethod, ApiClientArguments } from '../types';
+/**
+ * Union of allowed version keys and values for the bookmarks API.
+ *
+ * @template TAllowed - Subset of `ApiVersion` keys to include.
+ */
 export type FilterAllowedApiVersions<TAllowed extends string = keyof typeof ApiVersion> = FilterAllowApiVersionsBase<typeof ApiVersion, TAllowed>;
+/**
+ * Extracts the concrete version string from a key-or-value version identifier
+ * for the bookmarks API.
+ *
+ * @template TVersion - The version string to resolve.
+ * @template TAllowed - Constraint on allowed versions.
+ */
 export type ExtractApiVersion<TVersion extends string, TAllowed extends string = FilterAllowedApiVersions> = ExtractApiVersionBase<typeof ApiVersion, TVersion, TAllowed>;

package/dist/types/configurator.d.ts

@@ -1,7 +1,21 @@
 import type { ApiClientFactory } from './types';
+/**
+ * Configuration interface for the services module.
+ *
+ * Consumers can set `createClient` to override how HTTP clients are resolved
+ * for each backend service. When left `undefined`, the module automatically
+ * resolves clients through the HTTP module and service-discovery module.
+ */
 export interface IApiConfigurator {
-    /** Method for creating IHttpClients */
+    /** Optional factory for creating named HTTP clients. */
     createClient?: ApiClientFactory;
 }
+/**
+ * Default configurator for the services module.
+ *
+ * Implements {@link IApiConfigurator} with an initially empty configuration.
+ * The module initialization step populates `createClient` if it was not
+ * provided during configuration.
+ */
 export declare class ApiConfigurator implements IApiConfigurator {
 }

package/dist/types/context/api-models.d.ts

@@ -1,4 +1,5 @@
 import { ApiVersion } from './static';
+/** Context entity returned by the v1 context API. */
 type ApiContextEntity_v1 = {
     id: string;
     externalId: string | null;
@@ -11,22 +12,37 @@ type ApiContextEntity_v1 = {
     created: string;
     updated: string | null;
 };
+/** Placeholder for the v2 context entity (not yet defined). */
 type ApiContextEntity_v2 = unknown;
 type ApiContextEntityTypes = {
     [ApiVersion.v1]: ApiContextEntity_v1;
     [ApiVersion.v2]: ApiContextEntity_v2;
 };
+/**
+ * Version-aware context entity type.
+ *
+ * Resolves to the concrete entity shape for a given {@link ApiVersion}.
+ *
+ * @template T - An `ApiVersion` member (e.g. `ApiVersion.v1`).
+ */
 export type ApiContextEntity<T extends string = ApiVersion> = T extends ApiVersion ? ApiContextEntityTypes[T] : unknown;
 /** === types === */
+/** Context type metadata returned by the v1 context API. */
 type ApiContextType_v1 = {
     id: string;
     isChildType: boolean;
     parentTypeIds: string[] | null;
 };
+/** Placeholder for the v2 context type (not yet defined). */
 type ApiContextType_v2 = unknown;
 type ApiContextTypeTypes = {
     [ApiVersion.v1]: ApiContextType_v1;
     [ApiVersion.v2]: ApiContextType_v2;
 };
+/**
+ * Version-aware context type metadata.
+ *
+ * @template T - An `ApiVersion` member.
+ */
 export type ApiContextType<T extends ApiVersion> = ApiContextTypeTypes[T];
 export {};

package/dist/types/context/client.d.ts

@@ -4,24 +4,50 @@ import { ApiVersion } from './static';
 import { type GetContextFn, type GetContextResponse, type GetContextResult } from './get';
 import { type QueryContextFn, type QueryContextResponse, type QueryContextResult } from './query';
 import { type RelatedContextFn, type RelatedContextResponse, type RelatedContextResult } from './related';
+/**
+ * Typed API client for the Fusion context service.
+ *
+ * Delegates to versioned endpoint implementations for fetching a single context,
+ * querying contexts by search criteria, and listing related contexts.
+ *
+ * @template TMethod - The client execution method (`'json'` or `'json$'`).
+ * @template TClient - The underlying HTTP client type.
+ */
 export declare class ContextApiClient<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient> {
     protected _client: TClient;
     protected _method: TMethod;
+    /** Returns the {@link ApiVersion} enum for version-constant access. */
     get Version(): typeof ApiVersion;
+    /**
+     * @param _client - The HTTP client used to execute requests.
+     * @param _method - The execution method (`'json'` or `'json$'`).
+     */
     constructor(_client: TClient, _method: TMethod);
     /**
-     * Fetch context by id
-     * @see {@link get/client}
+     * Fetch a single context entity by its identifier.
+     *
+     * @template TVersion - The API version key (e.g. `'v1'`).
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns The context entity matching the provided arguments.
      */
     get<TVersion extends string = keyof typeof ApiVersion, TResult = GetContextResponse<TVersion>>(version: TVersion, ...args: Parameters<GetContextFn<TVersion, TMethod, TClient, TResult>>): GetContextResult<TVersion, TMethod, TResult>;
     /**
-     * Query context service
-     * @see {@link query/client}
+     * Query the context service with search criteria.
+     *
+     * @template TVersion - The API version key (e.g. `'v1'`).
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns An array of context entities matching the query.
      */
     query<TVersion extends string = keyof typeof ApiVersion, TResult = QueryContextResponse<TVersion>>(version: TVersion, ...args: Parameters<QueryContextFn<TVersion, TMethod, TClient, TResult>>): QueryContextResult<TVersion, TMethod, TResult>;
     /**
-     * Query context service
-     * @see {@link query/client}
+     * List contexts related to a specific context entity.
+     *
+     * @template TVersion - The API version key (e.g. `'v1'`).
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns An array of related context entities.
      */
     related<TVersion extends string = keyof typeof ApiVersion, TResult = RelatedContextResponse<TVersion>>(version: TVersion, ...args: Parameters<RelatedContextFn<TVersion, TMethod, TClient, TResult>>): RelatedContextResult<TVersion, TMethod, TResult>;
 }

package/dist/types/context/get/client.d.ts

@@ -2,10 +2,15 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ApiVersion } from '..';
 import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult } from './types';
 /**
- * Method for fetching context item from context service
- * @param client - client for execution of request
- * @param version - version of API to call
- * @param method - client method to call
+ * Creates a curried function that fetches a single context entity by ID.
+ *
+ * @template TVersion - The API version key (e.g. `'v1'`).
+ * @template TMethod - The client execution method (`'json'` or `'json$'`).
+ * @template TClient - The underlying HTTP client type.
+ * @param client - HTTP client used to execute the request.
+ * @param version - API version to call.
+ * @param method - Client method to use (defaults to `'json'`).
+ * @returns A function that accepts context args and returns the result.
  */
 export declare const getContext: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(client: TClient, version: TVersion, method?: TMethod) => <T = GetContextResponse<TVersion>>(args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetContextResult<TVersion, TMethod, T>;
 export default getContext;

package/dist/types/context/get/types.d.ts

@@ -1,7 +1,9 @@
 import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
 import { ApiVersion, type ApiContextEntity, type ClientMethod } from '..';
 export { ApiClientArguments, ClientMethod } from '..';
+/** Arguments for fetching a single context in API v1. */
 type GetContextArgs_v1 = {
+    /** The unique context identifier. */
     id: string;
 };
 type GetContextArgs_v2 = GetContextArgs_v1;
@@ -9,11 +11,36 @@ type GetContextArgsTypes = {
     [ApiVersion.v1]: GetContextArgs_v1;
     [ApiVersion.v2]: GetContextArgs_v2;
 };
+/**
+ * Version-aware argument type for the get-context endpoint.
+ *
+ * @template T - API version key.
+ */
 export type GetContextArgs<T extends string> = T extends keyof typeof ApiVersion ? GetContextArgsTypes[(typeof ApiVersion)[T]] : unknown;
 type GetContextResponseTypes = {
     [ApiVersion.v1]: ApiContextEntity<ApiVersion.v1>;
     [ApiVersion.v2]: ApiContextEntity<ApiVersion.v2>;
 };
+/**
+ * Version-aware response type for the get-context endpoint.
+ *
+ * @template T - API version key.
+ */
 export type GetContextResponse<T> = T extends keyof typeof ApiVersion ? GetContextResponseTypes[(typeof ApiVersion)[T]] : unknown;
+/**
+ * Function signature for the get-context endpoint.
+ *
+ * @template TVersion - API version key.
+ * @template TMethod - Client execution method.
+ * @template TClient - HTTP client type.
+ * @template TResult - Expected response type.
+ */
 export type GetContextFn<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = GetContextResponse<TVersion>> = (args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => GetContextResult<TVersion, TMethod, TResult>;
+/**
+ * Result type for the get-context endpoint, derived from `ClientMethod`.
+ *
+ * @template TVersion - API version key.
+ * @template TMethod - Client execution method.
+ * @template TResult - Expected response type.
+ */
 export type GetContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = GetContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

package/dist/types/context/index.d.ts

@@ -1,3 +1,16 @@
+/**
+ * @packageDocumentation
+ *
+ * Context API client and types.
+ *
+ * Provides {@link ContextApiClient} for fetching, querying, and listing
+ * related contexts, with versioned endpoints (`v1`, `v2`).
+ *
+ * @example
+ * ```ts
+ * import { ContextApiClient } from '@equinor/fusion-framework-module-services/context';
+ * ```
+ */
 export { ContextApiClient, default } from './client';
 export { ApiVersion } from './static';
 export { ApiContextEntity } from './api-models';

package/dist/types/context/query/client.d.ts

@@ -2,7 +2,15 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ApiVersion } from '..';
 import type { QueryContextArgs, QueryContextResponse, QueryContextResult, ClientMethod } from './types';
 /**
- * Function for querying the context service
+ * Creates a curried function that queries the context service.
+ *
+ * @template TVersion - The API version key.
+ * @template TMethod - The client execution method.
+ * @template TClient - The underlying HTTP client type.
+ * @param client - HTTP client used to execute the request.
+ * @param version - API version to call.
+ * @param method - Client method to use (defaults to `'json'`).
+ * @returns A function that accepts query args and returns context results.
  */
 export declare const queryContext: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(client: TClient, version: TVersion, method?: TMethod) => <T = QueryContextResponse<TVersion>>(args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => QueryContextResult<TVersion, TMethod, T>;
 export default queryContext;

package/dist/types/context/query/types.d.ts

@@ -1,10 +1,20 @@
 import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
 import { ApiVersion, type ApiContextEntity, type ClientMethod } from '..';
 export { ApiClientArguments, ClientMethod } from '..';
+/**
+ * OData filter parameters for context queries.
+ *
+ * Used to narrow results by context type or external identifier.
+ */
 export type QueryContextOdataFilter = {
     type?: string[];
     externalId?: string;
 };
+/**
+ * Structured OData query parameters for context search.
+ *
+ * Allows combining free-text search with type or external-ID filters.
+ */
 export type QueryContextOdataParameters = {
     search?: string;
     filter?: QueryContextOdataFilter;
@@ -18,6 +28,11 @@ type SearchContextArgTypes = {
     [ApiVersion.v1]: QueryContextArgs_v1;
     [ApiVersion.v2]: QueryContextArgs_v2;
 };
+/**
+ * Version-aware argument type for the context query endpoint.
+ *
+ * @template T - API version key.
+ */
 export type QueryContextArgs<T> = T extends keyof typeof ApiVersion ? SearchContextArgTypes[(typeof ApiVersion)[T]] : {
     query: {
         search: string;
@@ -27,6 +42,26 @@ type QueryContextResponseTypes = {
     [ApiVersion.v1]: Array<ApiContextEntity<ApiVersion.v1>>;
     [ApiVersion.v2]: Array<ApiContextEntity<ApiVersion.v2>>;
 };
+/**
+ * Version-aware response type for the context query endpoint.
+ *
+ * @template T - API version key.
+ */
 export type QueryContextResponse<T> = T extends keyof typeof ApiVersion ? QueryContextResponseTypes[(typeof ApiVersion)[T]] : unknown;
+/**
+ * Function signature for the context query endpoint.
+ *
+ * @template TVersion - API version key.
+ * @template TMethod - Client execution method.
+ * @template TClient - HTTP client type.
+ * @template TResult - Expected response type.
+ */
 export type QueryContextFn<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = QueryContextResponse<TVersion>> = (args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => QueryContextResult<TVersion, TMethod, TResult>;
+/**
+ * Result type for the context query endpoint.
+ *
+ * @template TVersion - API version key.
+ * @template TMethod - Client execution method.
+ * @template TResult - Expected response type.
+ */
 export type QueryContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = QueryContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

package/dist/types/context/related/client.d.ts

@@ -2,7 +2,15 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ApiVersion } from '..';
 import type { RelatedContextArgs, RelatedContextResponse, RelatedContextResult, ClientMethod } from './types';
 /**
- * Function for querying the context service
+ * Creates a curried function that fetches contexts related to a given context.
+ *
+ * @template TVersion - The API version key.
+ * @template TMethod - The client execution method.
+ * @template TClient - The underlying HTTP client type.
+ * @param client - HTTP client used to execute the request.
+ * @param version - API version to call.
+ * @param method - Client method to use (defaults to `'json'`).
+ * @returns A function that accepts relation args and returns related contexts.
  */
 export declare const relatedContexts: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(client: TClient, version: TVersion, method?: TMethod) => <T = RelatedContextResponse<TVersion>>(args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => RelatedContextResult<TVersion, TMethod, T>;
 export default relatedContexts;

package/dist/types/context/related/types.d.ts

@@ -1,13 +1,24 @@
 import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
 import { ApiVersion, type ApiContextEntity, type ClientMethod } from '..';
 export { ApiClientArguments, ClientMethod } from '..';
+/**
+ * Extended context entity that includes relationship metadata.
+ *
+ * @template T - An {@link ApiVersion} member.
+ */
 export type ApiRelatedContextEntity<T extends ApiVersion> = ApiContextEntity<T> & {
     relationSource: string;
     relationType: unknown;
 };
+/**
+ * OData filter for narrowing related-context results by type.
+ */
 export type RelatedContextOdataFilter = {
     type?: string[];
 };
+/**
+ * Structured OData query parameters for related-context lookups.
+ */
 export type RelatedContextOdataParameters = {
     search?: string;
     filter?: RelatedContextOdataFilter;
@@ -22,6 +33,11 @@ type RelatedContextArgTypes = {
     [ApiVersion.v1]: RelatedContextArgs_v1;
     [ApiVersion.v2]: RelatedContextArgs_v2;
 };
+/**
+ * Version-aware argument type for the related-contexts endpoint.
+ *
+ * @template T - API version key.
+ */
 export type RelatedContextArgs<T> = T extends keyof typeof ApiVersion ? RelatedContextArgTypes[(typeof ApiVersion)[T]] : {
     id: string;
 };
@@ -29,6 +45,26 @@ type RelatedContextResponseTypes = {
     [ApiVersion.v1]: Array<ApiRelatedContextEntity<ApiVersion.v1>>;
     [ApiVersion.v2]: Array<ApiRelatedContextEntity<ApiVersion.v2>>;
 };
+/**
+ * Version-aware response type for the related-contexts endpoint.
+ *
+ * @template T - API version key.
+ */
 export type RelatedContextResponse<T> = T extends keyof typeof ApiVersion ? RelatedContextResponseTypes[(typeof ApiVersion)[T]] : unknown;
+/**
+ * Function signature for the related-contexts endpoint.
+ *
+ * @template TVersion - API version key.
+ * @template TMethod - Client execution method.
+ * @template TClient - HTTP client type.
+ * @template TResult - Expected response type.
+ */
 export type RelatedContextFn<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = RelatedContextResponse<TVersion>> = (args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => RelatedContextResult<TVersion, TMethod, TResult>;
+/**
+ * Result type for the related-contexts endpoint.
+ *
+ * @template TVersion - API version key.
+ * @template TMethod - Client execution method.
+ * @template TResult - Expected response type.
+ */
 export type RelatedContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = RelatedContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

package/dist/types/context/static.d.ts

@@ -1,6 +1,7 @@
-/** index of api versions of context service */
+/** Supported API versions for the context service. */
 export declare enum ApiVersion {
+    /** Context API version 1.0. */
     v1 = "1.0",
-    /** not in use atm */
+    /** Context API version 2.0 (not currently in use). */
     v2 = "2.0"
 }

package/dist/types/errors.d.ts

@@ -1,4 +1,18 @@
+/**
+ * Error thrown when an API endpoint is called with a version string
+ * that does not match any supported API version.
+ *
+ * @example
+ * ```ts
+ * throw new UnsupportedApiVersion('3.0');
+ * // Error: unsupported version 3.0
+ * ```
+ */
 export declare class UnsupportedApiVersion extends Error {
     readonly version: string | number;
+    /**
+     * @param version - The unsupported version value that was requested.
+     * @param cause - Optional underlying error or context.
+     */
     constructor(version: string | number, cause?: unknown);
 }

package/dist/types/index.d.ts

@@ -1,3 +1,17 @@
+/**
+ * @packageDocumentation
+ *
+ * Typed API service clients for the Fusion Framework.\
+ * Provides factory-based access to bookmarks, context, notification, and
+ * people APIs with versioned endpoints, response validation, and support
+ * for both promise (`json`) and observable (`json$`) consumption patterns.
+ *
+ * @example
+ * ```ts
+ * import { enableServices } from '@equinor/fusion-framework-module-services';
+ * configurator.addConfig(enableServices);
+ * ```
+ */
 export * from './types';
 export type { ServicesModule, ServicesModuleKey } from './module';
 export { ApiConfigurator, IApiConfigurator } from './configurator';

package/dist/types/module.d.ts

@@ -3,28 +3,63 @@ import type { HttpModule } from '@equinor/fusion-framework-module-http';
 import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
 import { type IApiConfigurator } from './configurator';
 import { type IApiProvider } from './provider';
+/** String literal type for the services module registration key. */
 export type ServicesModuleKey = 'services';
+/** Module registration key used to identify the services module. */
 export declare const moduleKey: ServicesModuleKey;
+/**
+ * Module definition for the services module.
+ *
+ * Declares the module key, provider type ({@link IApiProvider}),
+ * configurator type ({@link IApiConfigurator}), and required
+ * dependency modules (HTTP and service-discovery).
+ */
 export type ServicesModule = Module<ServicesModuleKey, IApiProvider, IApiConfigurator, [
     HttpModule,
     ServiceDiscoveryModule
 ]>;
 /**
- *  Configure http-client
+ * Services module definition.
+ *
+ * Registers the `'services'` module, wires up the {@link ApiConfigurator},
+ * and initializes the {@link ApiProvider} with an HTTP client factory
+ * resolved from the `http` and optional `serviceDiscovery` modules.
  */
 export declare const module: ServicesModule;
 /**
- * Method for enabling the Service module
- * @param config - configuration object
+ * Registers the services module with the framework configurator.
+ *
+ * Call this during app configuration to make the services module
+ * available at runtime.
+ *
+ * @param config - The framework modules configurator.
+ *
+ * @example
+ * ```ts
+ * import { enableServices } from '@equinor/fusion-framework-module-services';
+ * configurator.addConfig(enableServices);
+ * ```
  */
 export declare const enableServices: (config: IModulesConfigurator<any, any>) => void;
 /**
+ * Creates a module configuration object for the services module
+ * with a custom configuration callback.
+ *
+ * Use this when you need to customise the services module (for example,
+ * supplying a custom `createClient` factory).
+ *
+ * @param configure - Callback that receives the {@link IApiConfigurator} for customisation.
+ * @returns A module configurator object that can be passed to `addConfig`.
+ *
  * @example
  * ```ts
- * config.addConfig(x => x.createClient(...));
+ * import { configureServices } from '@equinor/fusion-framework-module-services';
+ * configurator.addConfig(
+ *   configureServices((cfg) => {
+ *     cfg.createClient = myCustomClientFactory;
+ *   }),
+ * );
  * ```
- * @param configure - Callback for configuring the module
- * @returns Configuration object
  */
 export declare const configureServices: (configure: (configurator: IApiConfigurator) => void) => IModuleConfigurator<ServicesModule>;
 declare module '@equinor/fusion-framework-module' {

package/dist/types/notification/api-models.d.ts

@@ -1,4 +1,5 @@
 import { ApiVersion } from './static';
+/** Notification entity returned by the v1 notification API. */
 type ApiNotificationEntity_v1 = {
     id: string;
     appKey: string;
@@ -14,15 +15,18 @@ type ApiNotificationEntity_v1 = {
     seen: string;
     sourceSystem: SourceSystem_v1;
 };
+/** Source system metadata for a notification. */
 type SourceSystem_v1 = {
     name: string;
     subSystem: string;
     identifier: string;
 };
+/** Application that created the notification. */
 type CreatedByApplication_v1 = {
     id: string;
     title: string;
 };
+/** Person who created the notification. */
 type CreatedBy_v1 = {
     id: string;
     name: string;
@@ -30,26 +34,41 @@ type CreatedBy_v1 = {
     mail: string;
     accountType: string;
 };
+/** Placeholder for the v2 notification entity (not yet defined). */
 type ApiNotificationEntity_v2 = unknown;
 type ApiNotificationEntityTypes = {
     [ApiVersion.v1]: ApiNotificationEntity_v1;
     [ApiVersion.v2]: ApiNotificationEntity_v2;
 };
+/**
+ * Version-aware notification entity type.
+ *
+ * Resolves to the concrete entity shape for a given {@link ApiVersion}.
+ *
+ * @template T - An `ApiVersion` member string.
+ */
 export type ApiNotificationEntity<T extends string = ApiVersion> = T extends ApiVersion ? ApiNotificationEntityTypes[T] : unknown;
-/**User notification Settings */
+/** User notification settings entity for API v1. */
 type ApiNotificationSettingsEntity_v1 = {
     email: boolean;
     delayInMinutes: number;
     appConfig: AppConfig_v1[];
 };
+/** Per-application notification toggle within user settings. */
 type AppConfig_v1 = {
     appKey: string;
     enabled: boolean;
 };
+/** Placeholder for the v2 notification settings entity (not yet defined). */
 type ApiNotificationSettingsEntity_v2 = unknown;
 type ApiNotificationSettingEntityTypes = {
     [ApiVersion.v1]: ApiNotificationSettingsEntity_v1;
     [ApiVersion.v2]: ApiNotificationSettingsEntity_v2;
 };
+/**
+ * Version-aware notification settings entity type.
+ *
+ * @template T - An `ApiVersion` member string.
+ */
 export type ApiNotificationSettingsEntity<T extends string = ApiVersion> = T extends ApiVersion ? ApiNotificationSettingEntityTypes[T] : unknown;
 export {};