@equinor/fusion-framework-module-services 5.1.1-msal-0b0dadf270ee512f019a325c2f1586f91f9150a4 → 5.1.2

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

@@ -1,4 +1,4 @@
 export declare enum ApiVersion {
-    'v1' = "1.0",
-    'v2' = "2.0"
+    v1 = "1.0",
+    v2 = "2.0"
 }

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

@@ -1,14 +1,14 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod } from '../types';
-import { GetBookmarksArgs, GetBookmarksResponse, GetBookmarksResult, GetBookmarksVersion } from './endpoints/user-bookmarks.get';
-import { GetBookmarkArg, GetBookmarkResponse, GetBookmarkResult, GetBookmarkVersion } from './endpoints/bookmark.get';
-import { CreateBookmarkArg, CreateBookmarkResponse, CreateBookmarkVersion, CreateBookmarksResult } from './endpoints/bookmark.post';
+import { type GetBookmarksArgs, type GetBookmarksResponse, type GetBookmarksResult, type GetBookmarksVersion } from './endpoints/user-bookmarks.get';
+import { type GetBookmarkArg, type GetBookmarkResponse, type GetBookmarkResult, type GetBookmarkVersion } from './endpoints/bookmark.get';
+import { type CreateBookmarkArg, type CreateBookmarkResponse, type CreateBookmarkVersion, type CreateBookmarksResult } from './endpoints/bookmark.post';
 import { type PatchBookmarkArg, type PatchBookmarkResponse, type PatchBookmarkVersion, type PatchBookmarksResult } from './endpoints/bookmark.patch';
-import { BookmarkApplyArgs, BookmarkApplyResponse, BookmarkApplyResult, BookmarkApplyVersion } from './endpoints/bookmark-apply.get';
-import { AddBookmarkFavouriteArgs, AddBookmarkFavouriteResponse, AddBookmarkFavouriteResult, AddBookmarkFavouriteVersion } from './endpoints/user-bookmark-favourite.post';
-import { DeleteBookmarkArg, DeleteBookmarkResponse, DeleteBookmarkVersion } from './endpoints/bookmark.delete';
-import { IsFavoriteBookmarkArgs, IsFavoriteBookmarkResponse, IsFavoriteBookmarkResult, IsFavoriteBookmarkVersion } from './endpoints/user-bookmark-favourite.head';
-import { RemoveBookmarkFavouriteArgs, RemoveBookmarkFavouriteResponse, RemoveBookmarkFavouriteResult, RemoveBookmarkFavouriteVersion } from './endpoints/user-bookmark-favourite.delete';
+import { type BookmarkApplyArgs, type BookmarkApplyResponse, type BookmarkApplyResult, type BookmarkApplyVersion } from './endpoints/bookmark-apply.get';
+import { type AddBookmarkFavouriteArgs, type AddBookmarkFavouriteResponse, type AddBookmarkFavouriteResult, type AddBookmarkFavouriteVersion } from './endpoints/user-bookmark-favourite.post';
+import { type DeleteBookmarkArg, type DeleteBookmarkResponse, type DeleteBookmarkVersion } from './endpoints/bookmark.delete';
+import { type IsFavoriteBookmarkArgs, type IsFavoriteBookmarkResponse, type IsFavoriteBookmarkResult, type IsFavoriteBookmarkVersion } from './endpoints/user-bookmark-favourite.head';
+import { type RemoveBookmarkFavouriteArgs, type RemoveBookmarkFavouriteResponse, type RemoveBookmarkFavouriteResult, type RemoveBookmarkFavouriteVersion } from './endpoints/user-bookmark-favourite.delete';
 /**
  * Provides a client interface for interacting with the bookmarks API.
  * This class abstracts the details of making API requests and handling responses.

package/dist/types/bookmarks/endpoints/bookmark-apply.get.d.ts

@@ -37,4 +37,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as BookmarkApplyVersion, MethodArg as BookmarkApplyArgs, ApiResponse as BookmarkApplyResponse, MethodResult as BookmarkApplyResult, executeApiCall as getBookmarkApply, };
+export { type AllowedVersions as BookmarkApplyVersion, type MethodArg as BookmarkApplyArgs, type ApiResponse as BookmarkApplyResponse, type MethodResult as BookmarkApplyResult, executeApiCall as getBookmarkApply, };

package/dist/types/bookmarks/endpoints/bookmark.delete.d.ts

@@ -28,4 +28,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as DeleteBookmarkVersion, MethodArg as DeleteBookmarkArg, ApiResponse as DeleteBookmarkResponse, MethodResult as DeleteBookmarksResult, executeApiCall as deleteBookmark, };
+export { type AllowedVersions as DeleteBookmarkVersion, type MethodArg as DeleteBookmarkArg, type ApiResponse as DeleteBookmarkResponse, type MethodResult as DeleteBookmarksResult, executeApiCall as deleteBookmark, };

package/dist/types/bookmarks/endpoints/bookmark.get.d.ts

@@ -348,4 +348,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as GetBookmarkVersion, MethodArg as GetBookmarkArg, ApiResponse as GetBookmarkResponse, MethodResult as GetBookmarkResult, executeApiCall as getBookmark, };
+export { type AllowedVersions as GetBookmarkVersion, type MethodArg as GetBookmarkArg, type ApiResponse as GetBookmarkResponse, type MethodResult as GetBookmarkResult, executeApiCall as getBookmark, };

package/dist/types/bookmarks/endpoints/bookmark.patch.d.ts

@@ -251,4 +251,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as PatchBookmarkVersion, MethodArg as PatchBookmarkArg, ApiResponse as PatchBookmarkResponse, MethodResult as PatchBookmarksResult, executeApiCall as patchBookmark, };
+export { type AllowedVersions as PatchBookmarkVersion, type MethodArg as PatchBookmarkArg, type ApiResponse as PatchBookmarkResponse, type MethodResult as PatchBookmarksResult, executeApiCall as patchBookmark, };

package/dist/types/bookmarks/endpoints/bookmark.post.d.ts

@@ -228,4 +228,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as CreateBookmarkVersion, MethodArg as CreateBookmarkArg, ApiResponse as CreateBookmarkResponse, MethodResult as CreateBookmarksResult, executeApiCall as createBookmark, };
+export { type AllowedVersions as CreateBookmarkVersion, type MethodArg as CreateBookmarkArg, type ApiResponse as CreateBookmarkResponse, type MethodResult as CreateBookmarksResult, executeApiCall as createBookmark, };

package/dist/types/bookmarks/endpoints/user-bookmark-favourite.delete.d.ts

@@ -28,4 +28,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as RemoveBookmarkFavouriteVersion, MethodArg as RemoveBookmarkFavouriteArgs, ApiResponse as RemoveBookmarkFavouriteResponse, MethodResult as RemoveBookmarkFavouriteResult, executeApiCall as removeFavoriteBookmark, };
+export { type AllowedVersions as RemoveBookmarkFavouriteVersion, type MethodArg as RemoveBookmarkFavouriteArgs, type ApiResponse as RemoveBookmarkFavouriteResponse, type MethodResult as RemoveBookmarkFavouriteResult, executeApiCall as removeFavoriteBookmark, };

package/dist/types/bookmarks/endpoints/user-bookmark-favourite.head.d.ts

@@ -28,4 +28,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as IsFavoriteBookmarkVersion, MethodArg as IsFavoriteBookmarkArgs, ApiResponse as IsFavoriteBookmarkResponse, MethodResult as IsFavoriteBookmarkResult, executeApiCall as isFavoriteBookmark, };
+export { type AllowedVersions as IsFavoriteBookmarkVersion, type MethodArg as IsFavoriteBookmarkArgs, type ApiResponse as IsFavoriteBookmarkResponse, type MethodResult as IsFavoriteBookmarkResult, executeApiCall as isFavoriteBookmark, };

package/dist/types/bookmarks/endpoints/user-bookmark-favourite.post.d.ts

@@ -28,4 +28,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as AddBookmarkFavouriteVersion, MethodArg as AddBookmarkFavouriteArgs, ApiResponse as AddBookmarkFavouriteResponse, MethodResult as AddBookmarkFavouriteResult, executeApiCall as addBookmarkAsFavourite, };
+export { type AllowedVersions as AddBookmarkFavouriteVersion, type MethodArg as AddBookmarkFavouriteArgs, type ApiResponse as AddBookmarkFavouriteResponse, type MethodResult as AddBookmarkFavouriteResult, executeApiCall as addBookmarkAsFavourite, };

package/dist/types/bookmarks/endpoints/user-bookmarks.get.d.ts

@@ -449,4 +449,4 @@ type MethodArg<TVersion extends AllowedVersions> = z.input<(typeof ArgSchema)[Ex
 type MethodResult<TVersion extends AllowedVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = ApiResponse<TVersion>> = ClientMethod<TResult>[TMethod];
 /** executes the api call */
 declare const executeApiCall: <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(version: TVersion, client: IHttpClient, method?: TMethod) => <TResponse = ApiResponse<ExtractApiVersion<TVersion>>, TResult = MethodResult<ExtractApiVersion<TVersion>, TMethod, TResponse>>(input: MethodArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, TResponse>) => TResult;
-export { AllowedVersions as GetBookmarksVersion, MethodArg as GetBookmarksArgs, ApiResponse as GetBookmarksResponse, MethodResult as GetBookmarksResult, executeApiCall as getBookmarks, };
+export { type AllowedVersions as GetBookmarksVersion, type MethodArg as GetBookmarksArgs, type ApiResponse as GetBookmarksResponse, type MethodResult as GetBookmarksResult, executeApiCall as getBookmarks, };

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

@@ -1,4 +1,4 @@
-import { type ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
+import type { ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
 /**
  * A response selector that checks the status of an HTTP response and throws an error if the response is not successful.
  *

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

@@ -1,5 +1,5 @@
 import type { FilterAllowedApiVersions as FilterAllowApiVersionsBase, ExtractApiVersion as ExtractApiVersionBase } from '../types';
-import { ApiVersion } from './api-version';
+import type { ApiVersion } from './api-version';
 export { ClientMethodType, ClientMethod, ApiClientArguments } from '../types';
 export type FilterAllowedApiVersions<TAllowed extends string = keyof typeof ApiVersion> = FilterAllowApiVersionsBase<typeof ApiVersion, TAllowed>;
 export type ExtractApiVersion<TVersion extends string, TAllowed extends string = FilterAllowedApiVersions> = ExtractApiVersionBase<typeof ApiVersion, TVersion, TAllowed>;

package/dist/types/configurator.d.ts

@@ -1,4 +1,4 @@
-import { ApiClientFactory } from './types';
+import type { ApiClientFactory } from './types';
 export interface IApiConfigurator {
     /** Method for creating IHttpClients */
     createClient?: ApiClientFactory;

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

@@ -1,9 +1,9 @@
-import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { IHttpClient } from '@equinor/fusion-framework-module-http';
 import type { ClientMethod } from './types';
 import { ApiVersion } from './static';
-import { GetContextFn, GetContextResponse, GetContextResult } from './get';
-import { QueryContextFn, QueryContextResponse, QueryContextResult } from './query';
-import { RelatedContextFn, RelatedContextResponse, RelatedContextResult } from './related';
+import { type GetContextFn, type GetContextResponse, type GetContextResult } from './get';
+import { type QueryContextFn, type QueryContextResponse, type QueryContextResult } from './query';
+import { type RelatedContextFn, type RelatedContextResponse, type RelatedContextResult } from './related';
 export declare class ContextApiClient<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient> {
     protected _client: TClient;
     protected _method: TMethod;

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

@@ -1,4 +1,5 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+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/get/types.d.ts

@@ -1,5 +1,5 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
-import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion, type ApiContextEntity, type ClientMethod } from '..';
 export { ApiClientArguments, ClientMethod } from '..';
 type GetContextArgs_v1 = {
     id: string;

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 { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+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 { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+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/query/types.d.ts

@@ -1,5 +1,5 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
-import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion, type ApiContextEntity, type ClientMethod } from '..';
 export { ApiClientArguments, ClientMethod } from '..';
 export type QueryContextOdataFilter = {
     type?: string[];

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

@@ -1,7 +1,8 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+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 { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+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/context/related/types.d.ts

@@ -1,5 +1,5 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
-import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion, type ApiContextEntity, type ClientMethod } from '..';
 export { ApiClientArguments, ClientMethod } from '..';
 export type ApiRelatedContextEntity<T extends ApiVersion> = ApiContextEntity<T> & {
     relationSource: string;

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

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

package/dist/types/module.d.ts

@@ -1,8 +1,8 @@
 import type { IModuleConfigurator, IModulesConfigurator, Module } from '@equinor/fusion-framework-module';
 import type { HttpModule } from '@equinor/fusion-framework-module-http';
 import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
-import { IApiConfigurator } from './configurator';
-import { IApiProvider } from './provider';
+import { type IApiConfigurator } from './configurator';
+import { type IApiProvider } from './provider';
 export type ServicesModuleKey = 'services';
 export declare const moduleKey: ServicesModuleKey;
 export type ServicesModule = Module<ServicesModuleKey, IApiProvider, IApiConfigurator, [

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

@@ -1,13 +1,13 @@
-import { IHttpClient } from '@equinor/fusion-framework-module-http';
-import { ClientMethod } from '../types';
-import { GetNotificationFn, GetNotificationResult } from './notification/get';
+import type { IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { ClientMethod } from '../types';
+import type { GetNotificationFn, GetNotificationResult } from './notification/get';
 import { ApiVersion } from './static';
-import { PatchNotificationFn, PatchNotificationResult } from './notification/patch';
-import { GetNotificationsFn, GetNotificationsResult } from './notification/getAll';
-import { PostNotificationResult, PostNotificationFn } from './notification/post';
-import { DeleteNotificationFn, DeleteNotificationResult } from './notification/delete';
-import { PutUserNotificationSettingsFn, PutUserNotificationSettingsResult } from './settings/put';
-import { GetUserNotificationSettingsFn, GetUserNotificationsSettingsResult } from './settings/get';
+import type { PatchNotificationFn, PatchNotificationResult } from './notification/patch';
+import type { GetNotificationsFn, GetNotificationsResult } from './notification/getAll';
+import type { PostNotificationResult, PostNotificationFn } from './notification/post';
+import type { DeleteNotificationFn, DeleteNotificationResult } from './notification/delete';
+import { type PutUserNotificationSettingsFn, type PutUserNotificationSettingsResult } from './settings/put';
+import { type GetUserNotificationSettingsFn, type GetUserNotificationsSettingsResult } from './settings/get';
 export declare class NotificationApiClient<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient> {
     protected _client: TClient;
     protected _method: TMethod;

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

@@ -1,5 +1,6 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
+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 { ApiClientArguments } from '../../types';
-import { DeleteNotificationArgs } from './types';
+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/delete/types.d.ts

@@ -1,6 +1,6 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
-import { ApiNotificationEntity } from '../../api-models';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod } from '../../../types';
+import type { ApiNotificationEntity } from '../../api-models';
 import { ApiVersion } from '../../static';
 type DeleteNotificationArgs_v1 = {
     id: string;

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

@@ -1,5 +1,6 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
+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 { ApiClientArguments } from '../../types';
-import { GetNotificationArgs } from './types';
+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/get/types.d.ts

@@ -1,6 +1,6 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
-import { ApiNotificationEntity } from '../../api-models';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod } from '../../../types';
+import type { ApiNotificationEntity } from '../../api-models';
 import { ApiVersion } from '../../static';
 type GetNotificationArgs_v1 = {
     id: string;

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

@@ -1,5 +1,6 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
+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 { ApiClientArguments } from '../../types';
-import { GetNotificationsArgs } from './types';
+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/getAll/types.d.ts

@@ -1,6 +1,6 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
-import { ApiNotificationEntity } from '../../api-models';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod } from '../../../types';
+import type { ApiNotificationEntity } from '../../api-models';
 import { ApiVersion } from '../../static';
 type GetNotificationsArgs_v1 = {
     userId: string;

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

@@ -1,5 +1,6 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
+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 { ApiClientArguments } from '../../types';
-import { PatchNotificationArgs } from './types';
+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/patch/types.d.ts

@@ -1,6 +1,6 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
-import { ApiNotificationEntity } from '../../api-models';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod } from '../../../types';
+import type { ApiNotificationEntity } from '../../api-models';
 import { ApiVersion } from '../../static';
 type PatchNotificationArgs_v1 = {
     id: string;

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

@@ -1,5 +1,6 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
+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;