@equinor/fusion-framework-module-services 4.1.0 → 4.1.1

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

@@ -36,6 +36,7 @@ type ApiNotificationEntityTypes = {
     [ApiVersion.v2]: ApiNotificationEntity_v2;
 };
 export type ApiNotificationEntity<T extends string = ApiVersion> = T extends ApiVersion ? ApiNotificationEntityTypes[T] : unknown;
+/**User notification Settings */
 type ApiNotificationSettingsEntity_v1 = {
     email: boolean;
     delayInMinutes: number;

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

@@ -13,12 +13,40 @@ export declare class NotificationApiClient<TMethod extends keyof ClientMethod<un
     protected _method: TMethod;
     get Version(): typeof ApiVersion;
     constructor(_client: TClient, _method: TMethod);
+    /**
+     * Fetch all notifications
+     * @see {@link getAll/client}
+     */
     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}
+     */
     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}
+     */
     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<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<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}
+     */
     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}
+     */
     updateSettings<TVersion extends string = keyof typeof ApiVersion, TResult = PostNotificationResult<TVersion>>(version: TVersion, ...args: Parameters<PutUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>): PutUserNotificationSettingsResult<TVersion, TMethod, TResult>;
 }
 export default NotificationApiClient;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../../../types';
 import type { DeleteNotificationArgs, DeleteNotificationResponse, DeleteNotificationResult } from './types';
-export declare const deleteNotification: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = DeleteNotificationResponse<TVersion>>(args: DeleteNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => DeleteNotificationResult<TVersion, TMethod, T>;
+/**
+ * Method for deleting notification item from notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const deleteNotification: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = DeleteNotificationResponse<TVersion>>(args: DeleteNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => DeleteNotificationResult<TVersion, TMethod, T>;
 export default deleteNotification;

package/dist/types/notification/notification/delete/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
 import type { DeleteNotificationArgs } from './types';
+/**
+ * Method for generating endpoint for getting notification by id
+ */
 export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: DeleteNotificationArgs<TVersion>) => string;

package/dist/types/notification/notification/delete/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../../types';
 import { DeleteNotificationArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: DeleteNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: DeleteNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../../../types';
 import type { GetNotificationArgs, GetNotificationResult, GetNotificationResponse } from './types';
-export declare const getNotificationById: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetNotificationResponse<TVersion>>(args: GetNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetNotificationResult<TVersion, TMethod, T>;
+/**
+ * Method for fetching a notification item from notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const getNotificationById: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetNotificationResponse<TVersion>>(args: GetNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetNotificationResult<TVersion, TMethod, T>;
 export default getNotificationById;

package/dist/types/notification/notification/get/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
 import type { GetNotificationArgs } from './types';
+/**
+ * Method for generating endpoint for getting notification by id
+ */
 export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: GetNotificationArgs<TVersion>) => string;

package/dist/types/notification/notification/get/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../../types';
 import { GetNotificationArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: GetNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: GetNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../../../types';
 import type { GetNotificationsArgs, GetNotificationsResult, GetNotificationsResponse } from './types';
-export declare const getNotifications: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetNotificationsResponse<TVersion>>(args: GetNotificationsArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetNotificationsResult<TVersion, TMethod, T>;
+/**
+ * Method for fetching all notifications item from notification service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const getNotifications: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetNotificationsResponse<TVersion>>(args: GetNotificationsArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetNotificationsResult<TVersion, TMethod, T>;
 export default getNotifications;

package/dist/types/notification/notification/getAll/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
 import type { GetNotificationsArgs } from './types';
+/**
+ * Method for generating endpoint for getting all notifications
+ */
 export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: GetNotificationsArgs<TVersion>) => string;

package/dist/types/notification/notification/getAll/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../../types';
 import { GetNotificationsArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: GetNotificationsArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: GetNotificationsArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../../../types';
 import type { PatchNotificationArgs, PatchNotificationResponse, PatchNotificationResult } from './types';
-export declare const updateSeenByUser: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = PatchNotificationResponse<TVersion>>(args: PatchNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => PatchNotificationResult<TVersion, TMethod, T>;
+/**
+ * Method for updating a notification item
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const updateSeenByUser: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = PatchNotificationResponse<TVersion>>(args: PatchNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => PatchNotificationResult<TVersion, TMethod, T>;
 export default updateSeenByUser;

package/dist/types/notification/notification/patch/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
 import type { PatchNotificationArgs } from './types';
+/**
+ * Method for generating endpoint for getting notification by id
+ */
 export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: PatchNotificationArgs<TVersion>) => string;

package/dist/types/notification/notification/patch/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../../types';
 import { PatchNotificationArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PatchNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PatchNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../../../types';
 import type { PostNotificationArgs, PostNotificationResult, PostNotificationResponse } from './types';
-export declare const createNotification: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = PostNotificationResponse<TVersion>>(args: PostNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => PostNotificationResult<TVersion, TMethod, T>;
+/**
+ * Method for creating a notification item
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const createNotification: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = PostNotificationResponse<TVersion>>(args: PostNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => PostNotificationResult<TVersion, TMethod, T>;
 export default createNotification;

package/dist/types/notification/notification/post/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
 import type { PostNotificationArgs } from './types';
+/**
+ * Method for generating endpoint for getting all notifications
+ */
 export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: PostNotificationArgs<TVersion>) => string;

package/dist/types/notification/notification/post/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../../types';
 import { PostNotificationArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PostNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PostNotificationArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../../../types';
 import type { GetUserNotificationSettingsArgs, GetUserNotificationsSettingsResult, GetUserNotificationSettingsResponse } from './types';
-export declare const getUserNotificationSettings: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetUserNotificationSettingsResponse<TVersion>>(args: GetUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetUserNotificationsSettingsResult<TVersion, TMethod, T>;
+/**
+ * Method for fetching user notification settings from the notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const getUserNotificationSettings: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetUserNotificationSettingsResponse<TVersion>>(args: GetUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetUserNotificationsSettingsResult<TVersion, TMethod, T>;
 export default getUserNotificationSettings;

package/dist/types/notification/settings/get/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
 import type { GetUserNotificationSettingsArgs } from './types';
+/**
+ * Method for generating endpoint for getting all notifications
+ */
 export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: GetUserNotificationSettingsArgs<TVersion>) => string;

package/dist/types/notification/settings/get/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../../types';
 import { GetUserNotificationSettingsArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: GetUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: GetUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../../../types';
 import type { PutUserNotificationSettingsArgs, PutUserNotificationSettingsResult, PutUserNotificationSettingsResponse } from './types';
-export declare const updateUserNotificationSettings: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = PutUserNotificationSettingsResponse<TVersion>>(args: PutUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => PutUserNotificationSettingsResult<TVersion, TMethod, T>;
+/**
+ * Method for fetching user notification settings from the notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const updateUserNotificationSettings: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = PutUserNotificationSettingsResponse<TVersion>>(args: PutUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => PutUserNotificationSettingsResult<TVersion, TMethod, T>;
 export default updateUserNotificationSettings;

package/dist/types/notification/settings/put/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
 import type { PutUserNotificationSettingsArgs } from './types';
+/**
+ * Method for generating endpoint for getting all notifications
+ */
 export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: PutUserNotificationSettingsArgs<TVersion>) => string;

package/dist/types/notification/settings/put/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../../types';
 import { PutUserNotificationSettingsArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PutUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PutUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,4 +1,6 @@
+/** index of api versions of context service */
 export declare enum ApiVersion {
     'v1' = "1.0",
+    /** not in use atm */
     'v2' = "2.0"
 }

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

@@ -27,7 +27,7 @@ export type ApiPerson_v4<TExpand extends Array<ApiPersonExpandProps_v4> = []> =
     accountClassification?: ApiAccountClassification;
     managerAzureUniqueId?: string;
     linkedAccounts?: Array<ApiProfileAccountLink>;
-} & Partial<ApiPersonExpandMap_v4> & {
+} & /** expanded */ Partial<ApiPersonExpandMap_v4> & {
     [K in TExpand[number]]: ApiPersonExpandMap_v4[K];
 };
 export type ApiCompanyInfo_v4 = {

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

@@ -8,8 +8,17 @@ export declare class PeopleApiClient<TClient extends IHttpClient = IHttpClient>
     protected _client: TClient;
     get Version(): typeof ApiVersion;
     constructor(_client: TClient);
+    /**
+     * Fetch person by id
+     */
     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
+     */
     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
+     */
     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>;
 }
 export default PeopleApiClient;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../types';
-import type { ApiResponse, ApiResult, ApiRequestArgs } from './types';
-export declare const client: <TVersion extends "v4", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, 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>;
+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
+ */
+export declare const client: <TVersion extends SupportedApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, 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/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
-import type { ApiRequestArgs } from './types';
-export declare const generateEndpoint: <TVersion extends "v4">(version: TVersion, args: ApiRequestArgs<TVersion>) => string;
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+/**
+ * Method for generating endpoint for getting context by id
+ */
+export declare const generateEndpoint: <TVersion extends SupportedApiVersion>(version: TVersion, args: ApiRequestArgs<TVersion>) => string;

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

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ApiClientArguments } from '../../types';
-import type { ApiRequestArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends "v4", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends SupportedApiVersion, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { type ClientRequestInit, type IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientDataMethod } from '../../types';
-import type { ApiResponse, ApiRequestArgs } from './types';
-export declare const client: <TVersion extends "v2", TMethod extends keyof ClientDataMethod = keyof ClientDataMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, 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];
+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
+ */
+export declare const client: <TVersion extends SupportedApiVersion, TMethod extends keyof ClientDataMethod = keyof ClientDataMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, 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/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
-import type { ApiRequestArgs } from './types';
-export declare const generateEndpoint: <TVersion extends "v2">(version: TVersion, args: ApiRequestArgs<TVersion>) => string;
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+/**
+ * Method for generating endpoint for getting context by id
+ */
+export declare const generateEndpoint: <TVersion extends SupportedApiVersion>(version: TVersion, args: ApiRequestArgs<TVersion>) => string;

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

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ApiClientArguments } from '../../types';
-import type { ApiRequestArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends SupportedApiVersion, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../types';
-import type { ApiResponse, ApiResult, ApiRequestArgs } from './types';
-export declare const client: <TVersion extends "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, 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>;
+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
+ */
+export declare const client: <TVersion extends SupportedApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, 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/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
-import type { ApiRequestArgs } from './types';
-export declare const generateEndpoint: <TVersion extends "v2">(version: TVersion, args: ApiRequestArgs<TVersion>) => string;
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+/**
+ * Method for generating endpoint for getting context by id
+ */
+export declare const generateEndpoint: <TVersion extends SupportedApiVersion>(version: TVersion, args: ApiRequestArgs<TVersion>) => string;

package/dist/types/people/query/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ApiClientArguments } from '../../types';
-import type { ApiRequestArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+/** function for creating http client arguments  */
+export declare const generateParameters: <TResult, TVersion extends SupportedApiVersion, TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,2 +1,3 @@
 import { ApiPerson } from './api-models';
-export declare const isApiPerson: <V extends "v2" | "v4">(version: V) => <T>(value: T) => value is T extends ApiPerson<V> ? T : never;
+import { ApiVersion } from './static';
+export declare const isApiPerson: <V extends keyof typeof ApiVersion>(version: V) => <T>(value: T) => value is T extends ApiPerson<V> ? T : never;

package/dist/types/provider.d.ts

@@ -6,12 +6,25 @@ import BookmarksApiClient from './bookmarks/client';
 import { NotificationApiClient } from './notification';
 import { PeopleApiClient } from './people/client';
 export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
+    /**
+     * @param method - Version of the service to use
+     */
     createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(method: TMethod): Promise<BookmarksApiClient<TMethod, TClient, TPayload>>;
+    /**
+     * @param method - Version of the service to use
+     */
     createContextClient<TMethod extends keyof ClientMethod>(method: TMethod): Promise<ContextApiClient<TMethod, TClient>>;
+    /**
+     * @param method - Version of the service to use
+     */
     createNotificationClient<TMethod extends keyof ClientMethod>(method: TMethod): Promise<NotificationApiClient<TMethod, TClient>>;
+    /**
+     * @param method - Version of the service to use
+     */
     createPeopleClient(): Promise<PeopleApiClient<TClient>>;
 }
 type ApiProviderCtorArgs<TClient extends IHttpClient = IHttpClient> = {
+    /** method for creating IHttpClients for api clients */
     createClient: ApiClientFactory<TClient>;
 };
 type ApiProviderErrorResponse = {

package/dist/types/types.d.ts

@@ -4,10 +4,27 @@ export type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> =
     path: string,
     init?: ClientRequestInit<TClient, TResult>
 ];
+/**
+ * Execute methods on the IHttpClient
+ */
 export type ClientMethod<T = unknown> = {
+    /**
+     * Fetch data async
+     * NOTE: data needs to be extracted from the response
+     */
     fetch: Promise<FetchResponse<T>>;
+    /**
+     * Fetch JSON data from a service
+     */
     json: Promise<T>;
+    /**
+     * Fetch data as an observable
+     * NOTE: data needs to be extracted from the response
+     */
     fetch$: StreamResponse<FetchResponse<T>>;
+    /**
+     * Fetch JSON data from a service as observable
+     */
     json$: StreamResponse<T>;
 };
 export type ClientDataMethod<T extends BlobResult = BlobResult> = {

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.1.0";
+export declare const version = "4.1.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-services",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "description": "",
   "sideEffects": false,
   "main": "dist/esm/index.js",
@@ -115,14 +115,14 @@
     "odata-query": "^7.0.4"
   },
   "devDependencies": {
-    "typescript": "^5.4.2",
-    "@equinor/fusion-framework-module": "^4.3.1",
-    "@equinor/fusion-framework-module-http": "^6.0.0",
-    "@equinor/fusion-framework-module-service-discovery": "^7.1.8"
+    "typescript": "^5.5.3",
+    "@equinor/fusion-framework-module": "^4.3.2",
+    "@equinor/fusion-framework-module-http": "^6.0.1",
+    "@equinor/fusion-framework-module-service-discovery": "^7.1.10"
   },
   "peerDependencies": {
     "odata-query": "^7.0.4",
-    "@equinor/fusion-framework-module": "^4.3.1"
+    "@equinor/fusion-framework-module": "^4.3.2"
   },
   "scripts": {
     "build": "tsc -b"

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '4.1.0';
+export const version = '4.1.1';