@equinor/fusion-framework-module-services 5.1.1 → 5.1.2

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

@@ -1,4 +1,5 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '..';
 import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult } from './types';
 /**
  * Method for fetching context item from context service
@@ -6,5 +7,5 @@ import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult
  * @param version - version of API to call
  * @param method - client method to call
  */
-export declare const getContext: <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 = GetContextResponse<TVersion>>(args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetContextResult<TVersion, TMethod, T>;
+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/generate-endpoint.d.ts

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

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

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '..';
 import type { ApiClientArguments, GetContextArgs } from './types';
 /** 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: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+export declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(version: TVersion, args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,4 +1,5 @@
 export { ContextApiClient, default } from './client';
 export { ApiVersion } from './static';
+export { ApiContextEntity } from './api-models';
 export * from './api-models';
 export * from './types';

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

@@ -1,7 +1,8 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '..';
 import type { QueryContextArgs, QueryContextResponse, QueryContextResult, ClientMethod } from './types';
 /**
  * Function for querying the context service
  */
-export declare const queryContext: <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 = QueryContextResponse<TVersion>>(args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => QueryContextResult<TVersion, TMethod, T>;
+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/generate-endpoint.d.ts

@@ -1,3 +1,13 @@
+import { ApiVersion } from '..';
 import type { QueryContextArgs } from './types';
-export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: QueryContextArgs<TVersion>) => string;
+/**
+ * Generates an endpoint URL based on the provided API version and query context arguments.
+ *
+ * @template TVersion - The type of the API version, defaults to the keys of `ApiVersion`.
+ * @param version - The API version to use for generating the endpoint.
+ * @param args - The query context arguments specific to the provided API version.
+ * @returns The generated endpoint URL as a string.
+ * @throws {UnsupportedApiVersion} If the provided API version is not supported.
+ */
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: QueryContextArgs<TVersion>) => string;
 export default generateEndpoint;

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

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '..';
 import type { QueryContextArgs, ApiClientArguments } from './types';
 /** Function for generating parameter for querying context service  */
-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: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+export declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(version: TVersion, args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,7 +1,8 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '..';
 import type { RelatedContextArgs, RelatedContextResponse, RelatedContextResult, ClientMethod } from './types';
 /**
  * Function for querying the context service
  */
-export declare const relatedContexts: <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 = RelatedContextResponse<TVersion>>(args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => RelatedContextResult<TVersion, TMethod, T>;
+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/generate-endpoint.d.ts

@@ -1,3 +1,13 @@
+import { ApiVersion } from '..';
 import type { RelatedContextArgs } from './types';
-export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: RelatedContextArgs<TVersion>) => string;
+/**
+ * Generates an endpoint URL based on the provided API version and arguments.
+ *
+ * @template TVersion - The type of the API version, defaults to the keys of `ApiVersion`.
+ * @param version - The API version to use for generating the endpoint.
+ * @param args - The arguments required to generate the endpoint, including `id` and `query`.
+ * @returns The generated endpoint URL as a string.
+ * @throws {UnsupportedApiVersion} If the provided API version is not supported.
+ */
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: RelatedContextArgs<TVersion>) => string;
 export default generateEndpoint;

package/dist/types/context/related/generate-parameters.d.ts

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '..';
 import type { RelatedContextArgs, ApiClientArguments } from './types';
 /** Function for generating parameter for querying context service  */
-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: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
+export declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(version: TVersion, args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -1,5 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 import type { DeleteNotificationArgs, DeleteNotificationResponse, DeleteNotificationResult } from './types';
 /**
  * Method for deleting notification item from notifications service
@@ -7,5 +8,5 @@ import type { DeleteNotificationArgs, DeleteNotificationResponse, DeleteNotifica
  * @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 declare const deleteNotification: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(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,5 +1,6 @@
+import { ApiVersion } from '../..';
 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;
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: DeleteNotificationArgs<TVersion>) => string;

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

@@ -1,6 +1,7 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '../../static';
 import type { ApiClientArguments } from '../../types';
 import type { DeleteNotificationArgs } from './types';
 /** 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 declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(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,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 import type { GetNotificationArgs, GetNotificationResult, GetNotificationResponse } from './types';
 /**
  * Method for fetching a notification item from notifications service
@@ -7,5 +8,5 @@ import type { GetNotificationArgs, GetNotificationResult, GetNotificationRespons
  * @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 declare const getNotificationById: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(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,5 +1,6 @@
+import { ApiVersion } from '../..';
 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;
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: GetNotificationArgs<TVersion>) => string;

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

@@ -1,6 +1,7 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '../../static';
 import type { ApiClientArguments } from '../../types';
 import type { GetNotificationArgs } from './types';
 /** 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 declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(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,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 import type { GetNotificationsArgs, GetNotificationsResult, GetNotificationsResponse } from './types';
 /**
  * Method for fetching all notifications item from notification service
@@ -7,5 +8,5 @@ import type { GetNotificationsArgs, GetNotificationsResult, GetNotificationsResp
  * @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 declare const getNotifications: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(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,5 +1,6 @@
+import { ApiVersion } from '../..';
 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;
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: GetNotificationsArgs<TVersion>) => string;

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

@@ -1,6 +1,7 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '../../static';
 import type { ApiClientArguments } from '../../types';
 import type { GetNotificationsArgs } from './types';
 /** 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 declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(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,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 import type { PatchNotificationArgs, PatchNotificationResponse, PatchNotificationResult } from './types';
 /**
  * Method for updating a notification item
@@ -7,5 +8,5 @@ import type { PatchNotificationArgs, PatchNotificationResponse, PatchNotificatio
  * @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 declare const updateSeenByUser: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(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,5 +1,6 @@
+import { ApiVersion } from '../..';
 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;
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: PatchNotificationArgs<TVersion>) => string;

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

@@ -1,6 +1,7 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '../../static';
 import type { ApiClientArguments } from '../../types';
 import type { PatchNotificationArgs } from './types';
 /** 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 declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(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,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 import type { PostNotificationArgs, PostNotificationResult, PostNotificationResponse } from './types';
 /**
  * Method for creating a notification item
@@ -7,5 +8,5 @@ import type { PostNotificationArgs, PostNotificationResult, PostNotificationResp
  * @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 declare const createNotification: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(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,5 +1,6 @@
+import { ApiVersion } from '../..';
 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;
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: PostNotificationArgs<TVersion>) => string;

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

@@ -1,6 +1,7 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '../../static';
 import type { ApiClientArguments } from '../../types';
 import type { PostNotificationArgs } from './types';
 /** 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 declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(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,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 import type { GetUserNotificationSettingsArgs, GetUserNotificationsSettingsResult, GetUserNotificationSettingsResponse } from './types';
 /**
  * Method for fetching user notification settings from the notifications service
@@ -7,5 +8,5 @@ import type { GetUserNotificationSettingsArgs, GetUserNotificationsSettingsResul
  * @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 declare const getUserNotificationSettings: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(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,5 +1,6 @@
+import { ApiVersion } from '../..';
 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;
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: GetUserNotificationSettingsArgs<TVersion>) => string;

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

@@ -1,6 +1,7 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '../../static';
 import type { ApiClientArguments } from '../../types';
 import type { GetUserNotificationSettingsArgs } from './types';
 /** 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 declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(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,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 import type { PutUserNotificationSettingsArgs, PutUserNotificationSettingsResult, PutUserNotificationSettingsResponse } from './types';
 /**
  * Method for fetching user notification settings from the notifications service
@@ -7,5 +8,5 @@ import type { PutUserNotificationSettingsArgs, PutUserNotificationSettingsResult
  * @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 declare const updateUserNotificationSettings: <TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient = IHttpClient>(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,5 +1,6 @@
+import { ApiVersion } from '../..';
 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;
+export declare const generateEndpoint: <TVersion extends string = keyof typeof ApiVersion>(version: TVersion, args: PutUserNotificationSettingsArgs<TVersion>) => string;

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

@@ -1,6 +1,7 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiVersion } from '../../static';
 import type { ApiClientArguments } from '../../types';
 import type { PutUserNotificationSettingsArgs } from './types';
 /** 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 declare const generateParameters: <TResult, TVersion extends string = keyof typeof ApiVersion, TClient extends IHttpClient = IHttpClient>(version: TVersion, args: PutUserNotificationSettingsArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -7,5 +7,5 @@ import type { ApiResponse, ApiResult, ApiRequestArgs, SupportedApiVersion } from
  * @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 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/generate-parameters.d.ts

@@ -2,5 +2,5 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ApiClientArguments } from '../../types';
 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 declare const generateParameters: <TResult, TVersion extends SupportedApiVersion, TClient extends IHttpClient = IHttpClient>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -7,5 +7,5 @@ import type { ApiResponse, ApiRequestArgs, SupportedApiVersion } from './types';
  * @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 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/generate-parameters.d.ts

@@ -2,5 +2,5 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ApiClientArguments } from '../../types';
 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 declare const generateParameters: <TResult, TVersion extends SupportedApiVersion, TClient extends IHttpClient = IHttpClient>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

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

@@ -7,5 +7,5 @@ import type { ApiResponse, ApiResult, ApiRequestArgs, SupportedApiVersion } from
  * @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 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/generate-parameters.d.ts

@@ -2,5 +2,5 @@ import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-m
 import type { ApiClientArguments } from '../../types';
 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 declare const generateParameters: <TResult, TVersion extends SupportedApiVersion, TClient extends IHttpClient = IHttpClient>(version: TVersion, args: ApiRequestArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => ApiClientArguments<TClient, TResult>;
 export default generateParameters;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.1.1";
+export declare const version = "5.1.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-services",
-  "version": "5.1.1",
+  "version": "5.1.2",
   "description": "",
   "sideEffects": false,
   "main": "dist/esm/index.js",
@@ -116,16 +116,20 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "typescript": "^5.5.4",
-    "@equinor/fusion-framework-module": "^4.3.6",
-    "@equinor/fusion-framework-module-http": "^6.2.2",
-    "@equinor/fusion-framework-module-service-discovery": "^8.0.7"
+    "@faker-js/faker": "^9.5.1",
+    "msw": "^2.7.3",
+    "typescript": "^5.8.2",
+    "vitest": "^2.0.5",
+    "@equinor/fusion-framework-module": "^4.3.7",
+    "@equinor/fusion-framework-module-http": "^6.2.3",
+    "@equinor/fusion-framework-module-service-discovery": "^8.0.8"
   },
   "peerDependencies": {
     "odata-query": "^7.0.4",
-    "@equinor/fusion-framework-module": "^4.3.6"
+    "@equinor/fusion-framework-module": "^4.3.7"
   },
   "scripts": {
-    "build": "tsc -b"
+    "build": "tsc -b",
+    "test": "vitest"
   }
 }

package/src/context/index.ts

@@ -2,5 +2,7 @@ export { ContextApiClient, default } from './client';
 
 export { ApiVersion } from './static';
 
+export { ApiContextEntity } from './api-models';
+
 export * from './api-models';
 export * from './types';

package/src/context/query/generate-endpoint.ts

@@ -10,39 +10,88 @@ import type {
   QueryContextOdataParameters,
 } from './types';
 
-const buildOdataFilter = (filterObj: QueryContextOdataFilter) => {
-  return Object.keys(filterObj).reduce((acc, key) => {
-    switch (key) {
-      case 'type':
-        return filterObj[key]?.length ? { ...acc, [key]: { in: filterObj[key] } } : acc;
-      default:
-        return { ...acc, [key]: filterObj[key as keyof typeof filterObj] };
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  }, {} as any);
-};
-
-const buildOdataObject = (parameters: QueryContextOdataParameters) => {
-  return Object.entries(parameters)
-    .filter(([_, value]) => !!value)
-    .reduce((acc, [key, value]) => {
+/**
+ * Builds an OData filter object from the given filter object.
+ *
+ * This function takes a `QueryContextOdataFilter` object and transforms it into an OData filter object.
+ * It iterates over the keys of the input object and processes each key according to specific rules.
+ *
+ * @param filterObj - The filter object to be transformed into an OData filter.
+ * @returns A record representing the OData filter.
+ *
+ * @example
+ * ```typescript
+ * const filterObj = { type: ['exampleType'], otherKey: 'value' };
+ * const odataFilter = buildOdataFilter(filterObj);
+ * // odataFilter will be { $filter: { in: ['exampleType'] }, otherKey: 'value' }
+ * ```
+ */
+function buildOdataFilter(filterObj: QueryContextOdataFilter) {
+  return Object.keys(filterObj).reduce(
+    (acc, key) => {
       switch (key) {
-        case 'filter':
-          return {
-            ...acc,
-            [key]: buildOdataFilter(value as QueryContextOdataFilter),
-          };
+        case 'type':
+          if (filterObj[key]?.length) {
+            acc[key] = { in: filterObj[key] };
+          }
+          break;
         default:
-          return { ...acc, [key]: parameters[key as keyof typeof parameters] };
+          acc[key] = filterObj[key as keyof typeof filterObj];
+          break;
       }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }, {} as any);
-};
+      return acc;
+    },
+    {} as Record<string, unknown>,
+  );
+}
 
-const createSearchParameters = (args: string | QueryContextOdataParameters) => {
+/**
+ * Builds an OData object from the given query context parameters.
+ *
+ * This function processes the provided parameters, filters out any entries with falsy values,
+ * and constructs an OData object. It handles specific keys, such as 'filter', with custom logic.
+ *
+ * @param parameters - The query context parameters to be converted into an OData object.
+ * @returns An OData object constructed from the provided parameters.
+ */
+function buildOdataObject(parameters: QueryContextOdataParameters) {
+  return Object.entries(parameters)
+    .filter(([_, value]) => !!value)
+    .reduce(
+      (acc, [key, value]) => {
+        switch (key) {
+          case 'filter':
+            acc[key] = buildOdataFilter(value as QueryContextOdataFilter);
+            break;
+          default:
+            acc[key] = parameters[key as keyof typeof parameters];
+            break;
+        }
+        return acc;
+      },
+      {} as Record<string, unknown>,
+    );
+}
+
+/**
+ * Creates search parameters based on the provided arguments.
+ *
+ * @param args - A string or an object containing OData query parameters.
+ * @returns A string representing the search parameters.
+ */
+function createSearchParameters(args: string | QueryContextOdataParameters) {
   return typeof args === 'string' ? args : buildOdataQuery(buildOdataObject(args));
-};
+}
 
+/**
+ * Generates an endpoint URL based on the provided API version and query context arguments.
+ *
+ * @template TVersion - The type of the API version, defaults to the keys of `ApiVersion`.
+ * @param version - The API version to use for generating the endpoint.
+ * @param args - The query context arguments specific to the provided API version.
+ * @returns The generated endpoint URL as a string.
+ * @throws {UnsupportedApiVersion} If the provided API version is not supported.
+ */
 export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
   version: TVersion,
   args: QueryContextArgs<TVersion>,