@equinor/fusion-framework-module-services 7.2.2-next.0 → 8.0.0

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

@@ -8,44 +8,86 @@ import type { PostNotificationResult, PostNotificationFn } from './notification/
 import type { DeleteNotificationFn, DeleteNotificationResult } from './notification/delete';
 import { type PutUserNotificationSettingsFn, type PutUserNotificationSettingsResult } from './settings/put';
 import { type GetUserNotificationSettingsFn, type GetUserNotificationsSettingsResult } from './settings/get';
+/**
+ * Typed API client for the Fusion notification service.
+ *
+ * Provides methods for notification CRUD operations, marking notifications
+ * as seen, and managing user notification settings.
+ *
+ * @template TMethod - The client execution method (`'json'` or `'json$'`).
+ * @template TClient - The underlying HTTP client type.
+ */
 export declare class NotificationApiClient<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 all notifications
-     * @see {@link getAll/client}
+     * Fetch all notifications for the current user.
+     *
+     * @template TVersion - The API version key.
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns All notifications matching the query.
      */
     getAll<TVersion extends string = keyof typeof ApiVersion, TResult = GetNotificationsResult<TVersion>>(version: TVersion, ...args: Parameters<GetNotificationsFn<TVersion, TMethod, TClient, TResult>>): GetNotificationsResult<TVersion, TMethod, TResult>;
     /**
-     * Fetch notification by id
-     * @see {@link getById/client}
+     * Fetch a single notification by its identifier.
+     *
+     * @template TVersion - The API version key.
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns The notification with the specified ID.
      */
     getById<TVersion extends string = keyof typeof ApiVersion, TResult = GetNotificationResult<TVersion>>(version: TVersion, ...args: Parameters<GetNotificationFn<TVersion, TMethod, TClient, TResult>>): GetNotificationResult<TVersion, TMethod, TResult>;
     /**
-     * Set notification seen by user
-     * @see {@link setSeenByUser/client}
+     * Mark a notification as seen by the current user.
+     *
+     * @template TVersion - The API version key.
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns The updated notification.
      */
     setSeenByUser<TVersion extends string = keyof typeof ApiVersion, TResult = PatchNotificationResult<TVersion>>(version: TVersion, ...args: Parameters<PatchNotificationFn<TVersion, TMethod, TClient, TResult>>): PatchNotificationResult<TVersion, TMethod, TResult>;
     /**
-     * Create a notification
-     * @see {@link create/client}
+     * Create a new notification.
+     *
+     * @template TVersion - The API version key.
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns The created notification.
      */
     create<TVersion extends string = keyof typeof ApiVersion, TResult = PostNotificationResult<TVersion>>(version: TVersion, ...args: Parameters<PostNotificationFn<TVersion, TMethod, TClient, TResult>>): PostNotificationResult<TVersion, TMethod, TResult>;
     /**
-     * Delete a notification
-     * @see {@link delete/client}
+     * Delete a notification by its identifier.
+     *
+     * @template TVersion - The API version key.
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns The deletion result.
      */
     delete<TVersion extends string = keyof typeof ApiVersion, TResult = PostNotificationResult<TVersion>>(version: TVersion, ...args: Parameters<DeleteNotificationFn<TVersion, TMethod, TClient, TResult>>): DeleteNotificationResult<TVersion, TMethod, TResult>;
     /**
-     * Get users notification settings
-     * @see {@link getSettings/client}
+     * Retrieve the current user's notification settings.
+     *
+     * @template TVersion - The API version key.
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns The user's notification settings.
      */
     getSettings<TVersion extends string = keyof typeof ApiVersion, TResult = PostNotificationResult<TVersion>>(version: TVersion, ...args: Parameters<GetUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>): GetUserNotificationsSettingsResult<TVersion, TMethod, TResult>;
     /**
-     * Update user notification settings
-     * @see {@link updateSettings/client}
+     * Update the current user's notification settings.
+     *
+     * @template TVersion - The API version key.
+     * @template TResult - The expected response type.
+     * @param version - API version to use.
+     * @returns The updated notification settings.
      */
     updateSettings<TVersion extends string = keyof typeof ApiVersion, TResult = PostNotificationResult<TVersion>>(version: TVersion, ...args: Parameters<PutUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>): PutUserNotificationSettingsResult<TVersion, TMethod, TResult>;
 }

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

@@ -1,3 +1,17 @@
+/**
+ * @packageDocumentation
+ *
+ * Notification API client and types.
+ *
+ * Provides {@link NotificationApiClient} for creating, fetching, deleting
+ * notifications, marking them as seen, and managing user notification
+ * settings, with versioned endpoints (`v1`, `v2`).
+ *
+ * @example
+ * ```ts
+ * import { NotificationApiClient } from '@equinor/fusion-framework-module-services/notification';
+ * ```
+ */
 export { NotificationApiClient, default } from './client';
 export { ApiVersion } from './static';
 export * from './api-models';

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

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

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

@@ -1,10 +1,12 @@
 import type { ApiPerson_v2 } from './api-models.v2';
 import type { ApiPerson_v4 } from './api-models.v4';
 import { ApiVersion } from './static';
+/** Project master reference attached to a person's contract. */
 export type ApiProjectMaster = {
     id: string;
     name?: string;
 };
+/** Manager information with contact details and classification. */
 export type ApiManager = {
     azureUniqueId: string;
     name?: string;
@@ -16,9 +18,13 @@ export type ApiManager = {
     accountType: ApiProfileAccountType;
     accountClassification: ApiAccountClassification;
 };
+/** Invitation status for a person's account. */
 export type ApiInvitationStatus = 'Accepted' | 'Pending' | 'NotSent';
+/** Account type classification for a person profile. */
 export type ApiProfileAccountType = 'Employee' | 'Consultant' | 'Enterprise' | 'External' | 'External Hire';
+/** Account classification tier for access control. */
 export type ApiAccountClassification = 'Unclassified' | 'Internal' | 'External';
+/** Linked account reference for a person profile. */
 export type ApiProfileAccountLink = {
     azureUniqueId: string;
     mail?: string;
@@ -27,11 +33,26 @@ export type ApiProfileAccountLink = {
     isExpired?: boolean;
     upn?: string;
 };
+/**
+ * Map from API version to the corresponding person entity type.
+ *
+ * @see {@link ApiPerson_v2}
+ * @see {@link ApiPerson_v4}
+ */
 export type ApiPersonMap = {
     [ApiVersion.v2]: ApiPerson_v2;
     [ApiVersion.v4]: ApiPerson_v4;
 };
+/**
+ * Version-aware person entity type.
+ *
+ * Resolves to the concrete person shape for a given {@link ApiVersion}
+ * key or value.
+ *
+ * @template T - An `ApiVersion` key or value.
+ */
 export type ApiPerson<T extends keyof typeof ApiVersion | ApiVersion> = T extends ApiVersion ? ApiPersonMap[T] : T extends keyof typeof ApiVersion ? ApiPersonMap[(typeof ApiVersion)[T]] : unknown;
+/** Person suggestion result with account type and department detail. */
 export type ApiSuggestionPerson = {
     accountType?: 'Unknown' | 'Employee' | 'Consultant' | 'Enterprise' | 'EnterpriseExternal' | 'External' | 'Local' | 'TemporaryEmployee' | 'System' | 'Admin' | 'MeetingRoom';
     jobTitle?: string;
@@ -42,11 +63,13 @@ export type ApiSuggestionPerson = {
     upn?: string;
     mobilePhone?: string;
 };
+/** Application entity in a person suggestion result. */
 export type ApiSuggestionApplication = {
     applicationId: string;
     applicationName?: string;
     servicePrincipalType: 'Application' | 'ManagedIdentity' | 'ServicePrincipal';
 };
+/** Single suggestion value representing a person or system account. */
 export type ApiSuggestionValue = {
     azureUniqueId: string;
     name?: string;
@@ -58,12 +81,14 @@ export type ApiSuggestionValue = {
     avatarUrl: string;
     isExpired: boolean;
 };
+/** Paginated suggestion response from the people suggest endpoint. */
 export type ApiSuggestions = {
     totalCount: number;
     count: number;
     '@nextPage': string | null;
     value: Array<ApiSuggestionValue>;
 };
+/** Single resolved item from the people resolve endpoint. */
 export type ApiResolveItem = {
     success: boolean;
     statusCode: number;
@@ -71,4 +96,5 @@ export type ApiResolveItem = {
     identifier: string;
     account: ApiSuggestionValue | null;
 };
+/** Array of resolved person lookup results. */
 export type ApiResolved = Array<ApiResolveItem>;

package/dist/types/people/api-models.v2.d.ts

@@ -1,4 +1,5 @@
 import type { ApiAccountClassification, ApiInvitationStatus, ApiProfileAccountLink, ApiProfileAccountType } from './api-models';
+/** Person entity returned by the v2 people API. */
 export type ApiPerson_v2 = {
     fusionPersonId?: string;
     azureUniqueId: string;

package/dist/types/people/api-models.v4.d.ts

@@ -1,4 +1,10 @@
 import type { ApiAccountClassification, ApiInvitationStatus, ApiManager, ApiProfileAccountLink, ApiProfileAccountType, ApiProjectMaster } from './api-models';
+/**
+ * Map of expandable properties available on a v4 person entity.
+ *
+ * Use the `expand` parameter in API requests to include these
+ * nested collections alongside the core person data.
+ */
 export type ApiPersonExpandMap_v4 = {
     roles: Array<ApiPersonRole_v4>;
     positions: Array<ApiPersonPosition_v4>;
@@ -6,7 +12,17 @@ export type ApiPersonExpandMap_v4 = {
     manager: ApiManager;
     companies: Array<ApiCompanyInfo_v4>;
 };
+/** Union of valid expand property keys for the v4 person entity. */
 export type ApiPersonExpandProps_v4 = keyof ApiPersonExpandMap_v4;
+/**
+ * Person entity returned by the v4 people API.
+ *
+ * Includes only the expanded properties specified by `TExpand`.
+ * Non-expanded properties from {@link ApiPersonExpandMap_v4} remain
+ * `Partial` (i.e. `undefined` at runtime).
+ *
+ * @template TExpand - Array of expand property keys to include.
+ */
 export type ApiPerson_v4<TExpand extends Array<ApiPersonExpandProps_v4> = []> = {
     azureUniqueId: string;
     mail?: string;
@@ -30,10 +46,12 @@ export type ApiPerson_v4<TExpand extends Array<ApiPersonExpandProps_v4> = []> =
 } & /** expanded */ Partial<ApiPersonExpandMap_v4> & {
     [K in TExpand[number]]: ApiPersonExpandMap_v4[K];
 };
+/** Company information associated with a v4 person entity. */
 export type ApiCompanyInfo_v4 = {
     id: string;
     name?: string;
 };
+/** Role assigned to a person in the v4 API. */
 export type ApiPersonRole_v4 = {
     name?: string;
     displayName?: string;
@@ -44,11 +62,13 @@ export type ApiPersonRole_v4 = {
     onDemandSupport?: boolean;
     scopes?: Array<ApiPersonRoleScope_v4>;
 };
+/** Scope constraint on a person role. */
 export type ApiPersonRoleScope_v4 = {
     type?: string;
     values?: string[];
     valueType?: string;
 };
+/** Position instance held by a person in the v4 API. */
 export type ApiPersonPosition_v4 = {
     positionId: string;
     positionExternalId?: string;
@@ -63,18 +83,21 @@ export type ApiPersonPosition_v4 = {
     appliesTo: string;
     workload?: number;
 };
+/** Base position reference for a person position. */
 export type ApiPersonBasePosition_v4 = {
     id: string;
     name?: string;
     type?: string;
     discipline?: string;
 };
+/** Project reference for a person position or contract. */
 export type ApiPersonProject_v4 = {
     id: string;
     name?: string;
     domainId?: string;
     type?: string;
 };
+/** Contract associated with a person in the v4 API. */
 export type ApiPersonContract_v4 = {
     id: string;
     name?: string;
@@ -85,6 +108,7 @@ export type ApiPersonContract_v4 = {
     projectMaster: ApiProjectMaster;
     positions: Array<ApiPersonPosition_v4>;
 };
+/** @deprecated Use {@link ApiCompanyInfo_v4} instead. */
 export type ApiCompanyInfoV4 = {
     id: string;
     name?: string;

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

@@ -6,28 +6,81 @@ import { type ApiResponse as PersonQueryApiResponse, type ApiResult as PersonQue
 import { type ApiResponse as PersonPhotoApiResponse, type ApiResult as PersonPhotoResult, type SupportedApiVersion as PersonPhotoSupportedApiVersion, type ApiRequestArgs as PersonPhotoApiRequestArgs } from './person-photo';
 import { type ApiResponse as PersonSuggestApiResponse, type ApiResult as PersonSuggestResult } from './suggest';
 import { type ApiResponse as PersonResolveApiResponse, type ApiResult as PersonResolveResult } from './resolve';
+/**
+ * Typed API client for the Fusion people service.
+ *
+ * Provides methods for fetching person details, querying persons,
+ * retrieving profile photos, getting suggestions, and resolving
+ * person identifiers.
+ *
+ * @template TClient - The underlying HTTP client type.
+ */
 export declare class PeopleApiClient<TClient extends IHttpClient = IHttpClient> {
     protected _client: TClient;
+    /** Returns the {@link ApiVersion} enum for version-constant access. */
     get Version(): typeof ApiVersion;
+    /** @param _client - The HTTP client used to execute people requests. */
     constructor(_client: TClient);
     /**
-     * Fetch person by id
+     * Fetch detailed information about a person by their Azure unique ID.
+     *
+     * @template TVersion - The API version key (e.g. `'v4'`).
+     * @template TArgs - Request argument type.
+     * @template TResult - Expected response type.
+     * @template TMethod - Client execution method (`'json'` or `'json$'`).
+     * @param version - API version to use.
+     * @param method - Client execution method.
+     * @param args - Request arguments including `azureId`.
+     * @param init - Optional request init overrides.
+     * @returns The person details.
      */
     get<TVersion extends PersonDetailSupportedApiVersion, TArgs extends PersonDetailApiRequestArgs<TVersion>, TResult extends PersonDetailApiResponse<TVersion, TArgs>, TMethod extends keyof ClientMethod<TResult>>(version: TVersion, method: TMethod, args: TArgs, init?: ClientRequestInit<TClient, TResult>): PersonDetailResult<TVersion, TArgs, TMethod, TResult>;
     /**
-     * Query person service
+     * Search for persons matching query criteria.
+     *
+     * @template TVersion - The API version key (e.g. `'v2'`).
+     * @template TArgs - Request argument type.
+     * @template TResult - Expected response type.
+     * @template TMethod - Client execution method.
+     * @param version - API version to use.
+     * @param method - Client execution method.
+     * @param args - Request arguments including `search` string.
+     * @param init - Optional request init overrides.
+     * @returns An array of matching person entities.
      */
     query<TVersion extends PersonQuerySupportedApiVersion, TArgs extends PersonQueryApiRequestArgs<TVersion>, TResult = PersonQueryApiResponse<TVersion>, TMethod extends keyof ClientMethod<TResult> = keyof ClientMethod<TResult>>(version: TVersion, method: TMethod, args: TArgs, init?: ClientRequestInit<TClient, TResult>): PersonQueryResult<TVersion, TMethod, TResult>;
     /**
-     * Photo person service
+     * Fetch a person's profile photo as binary blob data.
+     *
+     * @template TVersion - The API version key (e.g. `'v2'`).
+     * @template TArgs - Request argument type.
+     * @template TResult - Expected response type.
+     * @template TMethod - Client execution method (`'blob'` or `'blob$'`).
+     * @param version - API version to use.
+     * @param method - Client execution method.
+     * @param args - Request arguments including `azureId`.
+     * @param init - Optional request init overrides.
+     * @returns The person's photo as a blob.
      */
     photo<TVersion extends PersonPhotoSupportedApiVersion, TArgs extends PersonPhotoApiRequestArgs<TVersion>, TResult extends PersonPhotoApiResponse<TVersion> = PersonPhotoApiResponse<TVersion>, TMethod extends keyof ClientDataMethod = keyof ClientDataMethod>(version: TVersion, method: TMethod, args: TArgs, init?: ClientRequestInit<TClient, TResult>): PersonPhotoResult<TMethod>;
     /**
-     * Suggest person service
+     * Fetch person suggestions (type-ahead / autocomplete).
+     *
+     * @template TResult - Expected response type.
+     * @template TMethod - Client execution method.
+     * @param method - Client execution method.
+     * @param init - Optional request init overrides.
+     * @returns Paginated suggestion results.
      */
     suggest<TResult = PersonSuggestApiResponse, TMethod extends keyof ClientMethod<TResult> = keyof ClientMethod<TResult>>(method: TMethod, init?: ClientRequestInit<TClient, TResult>): PersonSuggestResult<TMethod, TResult>;
     /**
-     * Resolve person service
+     * Resolve person identifiers to account information.
+     *
+     * @template TResult - Expected response type.
+     * @template TMethod - Client execution method.
+     * @param method - Client execution method.
+     * @param init - Optional request init overrides.
+     * @returns Array of resolved person results.
      */
     resolve<TResult = PersonResolveApiResponse, TMethod extends keyof ClientMethod<TResult> = keyof ClientMethod<TResult>>(method: TMethod, init?: ClientRequestInit<TClient, TResult>): PersonResolveResult<TMethod, TResult>;
 }

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

@@ -1,3 +1,16 @@
+/**
+ * @packageDocumentation
+ *
+ * People API client and types.
+ *
+ * Provides {@link PeopleApiClient} for person lookups, search, photo retrieval,
+ * suggestions, and identifier resolution, with versioned endpoints (`v2`, `v4`).
+ *
+ * @example
+ * ```ts
+ * import { PeopleApiClient } from '@equinor/fusion-framework-module-services/people';
+ * ```
+ */
 export { PeopleApiClient, default } from './client';
 export { ApiVersion } from './static';
 export * from './api-models';

package/dist/types/people/person-details/client.d.ts

@@ -2,10 +2,16 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ClientMethod } from '../../types';
 import type { ApiResponse, ApiResult, ApiRequestArgs, SupportedApiVersion } 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 detailed person information.
+ *
+ * @template TVersion - Supported API version (e.g. `'v4'`).
+ * @template TMethod - Client execution method (`'json'` or `'json$'`).
+ * @template TClient - The underlying HTTP client type.
+ * @template TArgs - Request argument 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 person detail args and returns the result.
  */
 export declare const client: <TVersion extends SupportedApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient, TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>>(client: TClient, version: TVersion, method?: TMethod) => <T = ApiResponse<TVersion, TArgs>>(args: TArgs, init?: ClientRequestInit<TClient, T>) => ApiResult<TVersion, TArgs, TMethod, T>;
 export default client;

package/dist/types/people/person-details/types.d.ts

@@ -1,6 +1,7 @@
 import { ApiVersion } from '../static';
 import type { ApiPerson_v4, ApiPersonExpandProps_v4 } from '../api-models.v4';
 import type { ClientMethod } from '../../types';
+/** API versions that support the person-details endpoint. */
 export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v4'>;
 type ApiRequestArgsMap = {
     [ApiVersion.v4]: {
@@ -8,11 +9,31 @@ type ApiRequestArgsMap = {
         expand?: Array<ApiPersonExpandProps_v4>;
     };
 };
+/** Union of all valid request argument shapes across supported versions. */
 export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+/**
+ * Version-aware request argument type for the person-details endpoint.
+ *
+ * @template T - Supported API version key.
+ */
 export type ApiRequestArgs<T extends SupportedApiVersion> = ApiRequestArgsMap[(typeof ApiVersion)[T]];
 type ApiResponseTypes<TArgs extends AllowedArgs> = {
     [ApiVersion.v4]: ApiPerson_v4<TArgs['expand'] extends [] ? TArgs['expand'] : []>;
 };
+/**
+ * Version-aware response type for the person-details endpoint.
+ *
+ * @template T - Supported API version key.
+ * @template TArgs - Request argument type.
+ */
 export type ApiResponse<T extends SupportedApiVersion, TArgs extends AllowedArgs> = ApiResponseTypes<TArgs>[(typeof ApiVersion)[T]];
+/**
+ * Result type for the person-details endpoint.
+ *
+ * @template TVersion - Supported API version key.
+ * @template TArgs - Request argument type.
+ * @template TMethod - Client execution method.
+ * @template TResult - Expected response type.
+ */
 export type ApiResult<TVersion extends SupportedApiVersion, TArgs extends ApiRequestArgs<TVersion>, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion, TArgs>> = ClientMethod<TResult>[TMethod];
 export {};

package/dist/types/people/person-photo/client.d.ts

@@ -2,10 +2,16 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ClientDataMethod } from '../../types';
 import type { ApiResponse, ApiRequestArgs, SupportedApiVersion } 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 person's profile photo.
+ *
+ * @template TVersion - Supported API version (e.g. `'v2'`).
+ * @template TMethod - Client execution method (`'blob'` or `'blob$'`).
+ * @template TClient - The underlying HTTP client type.
+ * @template TArgs - Request argument type.
+ * @param client - HTTP client used to execute the request.
+ * @param version - API version to call.
+ * @param method - Client method to use (defaults to `'blob'`).
+ * @returns A function that accepts photo args and returns blob data.
  */
 export declare const client: <TVersion extends SupportedApiVersion, TMethod extends keyof ClientDataMethod = keyof ClientDataMethod, TClient extends IHttpClient = IHttpClient, TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>>(client: TClient, version: TVersion, method?: TMethod) => <T extends ApiResponse<TVersion> = ApiResponse<TVersion>>(args: TArgs, init?: ClientRequestInit<TClient, T>) => ClientDataMethod<T>[TMethod];
 export default client;

package/dist/types/people/person-photo/types.d.ts

@@ -1,17 +1,34 @@
 import type { BlobResult } from '@equinor/fusion-framework-module-http/client';
 import { ApiVersion } from '../static';
 import type { ClientDataMethod } from '../../types';
+/** API versions that support the person photo endpoint. */
 export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
 type ApiRequestArgsMap = {
     [ApiVersion.v2]: {
         azureId: string;
     };
 };
+/** Union of all valid request argument shapes across supported versions. */
 export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+/**
+ * Version-aware request argument type for the person photo endpoint.
+ *
+ * @template T - Supported API version key.
+ */
 export type ApiRequestArgs<T extends SupportedApiVersion> = ApiRequestArgsMap[(typeof ApiVersion)[T]];
 type ApiResponseTypes = {
     [ApiVersion.v2]: BlobResult;
 };
+/**
+ * Version-aware response type for the person photo endpoint.
+ *
+ * @template T - Supported API version key.
+ */
 export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
+/**
+ * Result type for the person photo endpoint.
+ *
+ * @template TMethod - Client execution method (`'blob'` or `'blob$'`).
+ */
 export type ApiResult<TMethod extends keyof ClientDataMethod = keyof ClientDataMethod> = ClientDataMethod[TMethod];
 export {};

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

@@ -2,10 +2,16 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ClientMethod } from '../../types';
 import type { ApiResponse, ApiResult, ApiRequestArgs, SupportedApiVersion } 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 queries the people service.
+ *
+ * @template TVersion - Supported API version (e.g. `'v2'`).
+ * @template TMethod - Client execution method.
+ * @template TClient - The underlying HTTP client type.
+ * @template TArgs - Request argument 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 person results.
  */
 export declare const client: <TVersion extends SupportedApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient, TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>>(client: TClient, version: TVersion, method?: TMethod) => <T = ApiResponse<TVersion>>(args: TArgs, init?: ClientRequestInit<TClient, T>) => ApiResult<TVersion, TMethod, T>;
 export default client;

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

@@ -1,17 +1,36 @@
 import { ApiVersion } from '../static';
 import type { ApiPerson_v2 } from '../api-models.v2';
 import type { ClientMethod } from '../../types';
+/** API versions that support the people query endpoint. */
 export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
 type ApiRequestArgsMap = {
     [ApiVersion.v2]: {
         search: string;
     };
 };
+/** Union of all valid request argument shapes across supported versions. */
 export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+/**
+ * Version-aware request argument type for the people query endpoint.
+ *
+ * @template T - Supported API version key.
+ */
 export type ApiRequestArgs<T extends SupportedApiVersion> = ApiRequestArgsMap[(typeof ApiVersion)[T]];
 type ApiResponseTypes = {
     [ApiVersion.v2]: Array<ApiPerson_v2>;
 };
+/**
+ * Version-aware response type for the people query endpoint.
+ *
+ * @template T - Supported API version key.
+ */
 export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
+/**
+ * Result type for the people query endpoint.
+ *
+ * @template TVersion - Supported API version key.
+ * @template TMethod - Client execution method.
+ * @template TResult - Expected response type.
+ */
 export type ApiResult<TVersion extends SupportedApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 export {};

package/dist/types/people/resolve/types.d.ts

@@ -1,4 +1,11 @@
 import type { ApiResolved } from '../api-models';
 import type { ClientMethod } from '../../types';
+/** Response type for the people resolve endpoint. */
 export type ApiResponse = ApiResolved;
+/**
+ * Result type for the people resolve endpoint.
+ *
+ * @template TMethod - Client execution method.
+ * @template TResult - Expected response type.
+ */
 export type ApiResult<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse> = ClientMethod<TResult>[TMethod];

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

@@ -1,4 +1,7 @@
+/** Supported API versions for the people service. */
 export declare enum ApiVersion {
+    /** People API version 2.0. */
     v2 = "2.0",
+    /** People API version 4.0. */
     v4 = "4.0"
 }

package/dist/types/people/suggest/types.d.ts

@@ -1,4 +1,11 @@
 import type { ApiSuggestions } from '../api-models';
 import type { ClientMethod } from '../../types';
+/** Response type for the people suggest endpoint. */
 export type ApiResponse = ApiSuggestions;
+/**
+ * Result type for the people suggest endpoint.
+ *
+ * @template TMethod - Client execution method.
+ * @template TResult - Expected response type.
+ */
 export type ApiResult<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse> = ClientMethod<TResult>[TMethod];

package/dist/types/people/utils.d.ts

@@ -1,3 +1,22 @@
 import type { ApiPerson } from './api-models';
 import { ApiVersion } from './static';
+/**
+ * Creates a type-guard function that validates whether a value conforms
+ * to the {@link ApiPerson} shape for a given API version.
+ *
+ * The guard checks that the value contains all required attributes
+ * defined for the specified version.
+ *
+ * @template V - API version key (e.g. `'v2'` or `'v4'`).
+ * @param version - The API version to validate against.
+ * @returns A type-guard function that narrows `T` to `ApiPerson<V>`.
+ *
+ * @example
+ * ```ts
+ * const isV4Person = isApiPerson('v4');
+ * if (isV4Person(data)) {
+ *   console.log(data.azureUniqueId);
+ * }
+ * ```
+ */
 export declare const isApiPerson: <V extends keyof typeof ApiVersion>(version: V) => <T>(value: T) => value is T extends ApiPerson<V> ? T : never;