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

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

@@ -12,13 +12,47 @@ export declare class BookmarksApiClient<TMethod extends keyof ClientMethod<unkno
     protected _client: TClient;
     protected _method: TMethod;
     constructor(_client: TClient, _method: TMethod);
+    /**
+     * Fetch bookmark by id
+     * @see {@link get/client}
+     */
     get<TVersion extends ApiVersions, TResult = GetBookmarkResult<TVersion, TPayload>>(version: TVersion, ...args: Parameters<GetBookmarksFn<TVersion, TMethod, TClient, TPayload, TResult>>): GetBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+    /**
+     * Fetch all bookmarks
+     * @see {@link get/client}
+     */
     getAll<TVersion extends ApiVersions, TResult = GetAllBookmarkResult<TVersion, TPayload>>(version: TVersion): GetAllBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+    /**
+     * Create a new bookmark
+     * @see {@link get/client}
+     */
     post<TVersion extends ApiVersions, TResult = PostBookmarkResult<TVersion, TPayload>>(version: TVersion, ...args: Parameters<PostBookmarkFn<TVersion, TMethod, TClient, TPayload, TResult>>): PostBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+    /**
+     * Update a bookmark
+     * @see {@link get/client}
+     */
     patch<TVersion extends ApiVersions, TResult = PatchBookmarkResult<TVersion, TPayload>>(version: TVersion, ...args: Parameters<PatchBookmarkFn<TVersion, TMethod, TClient, TPayload, TResult>>): PatchBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+    /**
+     * Delete a bookmark
+     * @see {@link delete/client}
+     */
     delete<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<DeleteBookmarksFn<TVersion, TMethod, TClient, TResult>>): DeleteBookmarksResult<TVersion, TMethod, TResult>;
+    /**
+     * Add bookmark to favorites by bookmark id
+     * @see {@link addFavorite/client}
+     */
     addFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<PostBookmarkFavoriteFn<TVersion, TMethod, TClient, TResult>>): PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+    /**
+     *
+     * Remove bookmark from favorites by bookmark id
+     * @see {@link removeFavorite/client}
+     */
     removeFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<DeleteBookmarksFavoriteFn<TVersion, TMethod, TClient, TResult>>): DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+    /**
+     *
+     * Verify that the current bookmark is present in the users collection of bookmarks.
+     * @see {@link verifyFavorite/client}
+     */
     verifyFavorite<TVersion extends ApiVersions, TResult = DeleteBookmarkResult<TVersion>>(version: TVersion, ...args: Parameters<HeadBookmarkFavoriteFn<TVersion, TMethod, TClient, TResult>>): HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
 }
 export default BookmarksApiClient;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { DeleteBookmarkArgs, DeleteBookmarkResult, DeleteBookmarksResult } from './types';
-export declare const deleteBookmark: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = DeleteBookmarkResult<TVersion>>(args: DeleteBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => DeleteBookmarksResult<TVersion, TMethod, TResult>;
+import { ApiVersions, DeleteBookmarkArgs, DeleteBookmarkResult, DeleteBookmarksResult } from './types';
+/**
+ * Method for fetching bookmark by it`s id from bookmark service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const deleteBookmark: <TVersion extends ApiVersions = "v1", 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) => <TResult = DeleteBookmarkResult<TVersion>>(args: DeleteBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => DeleteBookmarksResult<TVersion, TMethod, TResult>;
 export default deleteBookmark;

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

@@ -1,2 +1,5 @@
-import { DeleteBookmarkArgs } from './types';
-export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, args: DeleteBookmarkArgs<TVersion>) => string;
+import { ApiVersions, DeleteBookmarkArgs } from './types';
+/**
+ * Method for generating endpoint for deleting a bookmark.
+ */
+export declare const generateEndpoint: <TVersion extends ApiVersions>(version: TVersion, args: DeleteBookmarkArgs<TVersion>) => string;

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

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

package/dist/types/bookmarks/delete/types-v1.d.ts

@@ -1,3 +1,4 @@
+/** arguments for v1 delete bookmarks */
 export type DeleteBookmarksArgsV1 = {
     id: string;
 };

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

@@ -3,7 +3,9 @@ import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client'
 import { ClientMethod } from '../..';
 import { DeleteBookmarksArgsV1 } from './types-v1';
 export type DeleteBookmarkResult<TVersion extends ApiVersions> = DeleteBookmarksVersions[TVersion]['result'];
+/** Returns args for GetBookmark based on version*/
 export type DeleteBookmarkArgs<TVersion extends ApiVersions> = DeleteBookmarksVersions[TVersion]['args'];
+/**Gets result type for GetBookmark call based on version and method */
 export type DeleteBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = DeleteBookmarkResult<TVersion>> = ClientMethod<TResult>[TMethod];
 export type DeleteBookmarksFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TResult = DeleteBookmarkResult<TVersion>> = (args: DeleteBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => DeleteBookmarksResult<TVersion, TMethod, TResult>;
 export type DeleteBookmarksVersions = {
@@ -12,4 +14,5 @@ export type DeleteBookmarksVersions = {
         result: undefined;
     };
 };
+/**Api versions for bookmarks service */
 export type ApiVersions = keyof DeleteBookmarksVersions;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { DeleteBookmarkFavoriteArgs, DeleteBookmarkFavoriteResult, DeleteBookmarksFavoriteResult } from './types';
-export declare const deleteBookmarkFavorite: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = DeleteBookmarkFavoriteResult<TVersion>>(args: DeleteBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+import { ApiVersions, DeleteBookmarkFavoriteArgs, DeleteBookmarkFavoriteResult, DeleteBookmarksFavoriteResult } from './types';
+/**
+ * Method for fetching bookmark by it`s id from bookmark service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const deleteBookmarkFavorite: <TVersion extends ApiVersions = "v1", 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) => <TResult = DeleteBookmarkFavoriteResult<TVersion>>(args: DeleteBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => DeleteBookmarksFavoriteResult<TVersion, TMethod, TResult>;
 export default deleteBookmarkFavorite;

package/dist/types/bookmarks/favorites/delete/generate-endpoint.d.ts

@@ -1,2 +1,5 @@
-import { DeleteBookmarkFavoriteArgs } from './types';
-export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, args: DeleteBookmarkFavoriteArgs<TVersion>) => string;
+import { ApiVersions, DeleteBookmarkFavoriteArgs } from './types';
+/**
+ * Method for generating endpoint for deleting a bookmark.
+ */
+export declare const generateEndpoint: <TVersion extends ApiVersions>(version: TVersion, args: DeleteBookmarkFavoriteArgs<TVersion>) => string;

package/dist/types/bookmarks/favorites/delete/generate-parameters.d.ts

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

package/dist/types/bookmarks/favorites/delete/types-v1.d.ts

@@ -1,3 +1,4 @@
+/** arguments for v1 delete bookmark favorite */
 export type DeleteBookmarksFavoriteArgsV1 = {
     bookmarkId: string;
 };

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

@@ -12,4 +12,5 @@ export type DeleteBookmarksFavoriteVersions = {
         result: undefined;
     };
 };
+/**Api versions for bookmarks service */
 export type ApiVersions = keyof DeleteBookmarksFavoriteVersions;

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { HeadBookmarkFavoriteArgs, HeadBookmarkFavoriteResult, HeadBookmarksFavoriteResult } from './types';
-export declare const verifyBookmarkFavorite: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = HeadBookmarkFavoriteResult<TVersion>>(args: HeadBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+import { ApiVersions, HeadBookmarkFavoriteArgs, HeadBookmarkFavoriteResult, HeadBookmarksFavoriteResult } from './types';
+/**
+ * Verify that the bookmark is owned by the current user.
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const verifyBookmarkFavorite: <TVersion extends ApiVersions = "v1", 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) => <TResult = HeadBookmarkFavoriteResult<TVersion>>(args: HeadBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => HeadBookmarksFavoriteResult<TVersion, TMethod, TResult>;
 export default verifyBookmarkFavorite;

package/dist/types/bookmarks/favorites/head/generate-endpoint.d.ts

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

package/dist/types/bookmarks/favorites/head/generate-parameters.d.ts

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

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { PostBookmarkFavoriteArgs, PostBookmarkFavoriteResult, PostBookmarksFavoriteResult } from './types';
-export declare const addBookmarkFavorite: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PostBookmarkFavoriteResult<TVersion>>(args: PostBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
+import { ApiVersions, PostBookmarkFavoriteArgs, PostBookmarkFavoriteResult, PostBookmarksFavoriteResult } from './types';
+/**
+ * Method for adding other users bookmark to your favorites.
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const addBookmarkFavorite: <TVersion extends ApiVersions = "v1", 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) => <TResult = PostBookmarkFavoriteResult<TVersion>>(args: PostBookmarkFavoriteArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksFavoriteResult<TVersion, TMethod, TResult>;
 export default addBookmarkFavorite;

package/dist/types/bookmarks/favorites/post/generate-endpoint.d.ts

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

package/dist/types/bookmarks/favorites/post/generate-parameters.d.ts

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

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { GetBookmarkArgs, GetBookmarkResult, GetBookmarksResult } from './types';
-export declare const getBookmark: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = GetBookmarkResult<TVersion, unknown>>(args: GetBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => GetBookmarksResult<TVersion, TMethod, unknown, TResult>;
+import { ApiVersions, GetBookmarkArgs, GetBookmarkResult, GetBookmarksResult } from './types';
+/**
+ * Method for fetching bookmark by it`s id from bookmark service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const getBookmark: <TVersion extends ApiVersions = "v1", 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) => <TResult = GetBookmarkResult<TVersion, unknown>>(args: GetBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => GetBookmarksResult<TVersion, TMethod, unknown, TResult>;
 export default getBookmark;

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

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

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

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

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

@@ -3,7 +3,9 @@ import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client'
 import { ClientMethod } from '../..';
 import { ApiBookmarkEntityV1 } from '../api-models';
 export type GetBookmarkResult<TVersion extends ApiVersions, TPayload> = GetBookmarksVersions<TPayload>[TVersion]['result'];
+/** Returns args for GetBookmark based on version*/
 export type GetBookmarkArgs<TVersion extends ApiVersions> = GetBookmarksVersions[TVersion]['args'];
+/**Gets result type for GetBookmark call based on version and method */
 export type GetBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = GetBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
 export type GetBookmarksFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = GetBookmarkResult<TVersion, TPayload>> = (args: GetBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => GetBookmarksResult<TVersion, TMethod, TPayload, TResult>;
 type GetBookmarksArgsV1 = {

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { GetAllBookmarkResult, GetAllBookmarksResult } from './types';
-export declare const getAllBookmarks: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = GetAllBookmarkResult<TVersion, unknown>>(init?: ClientRequestInit<TClient, TResult>) => GetAllBookmarksResult<TVersion, TMethod, unknown, TResult>;
+import { ApiVersions, GetAllBookmarkResult, GetAllBookmarksResult } from './types';
+/**
+ * Method for fetching all bookmarks for the current user from bookmark service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const getAllBookmarks: <TVersion extends ApiVersions = "v1", 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) => <TResult = GetAllBookmarkResult<TVersion, unknown>>(init?: ClientRequestInit<TClient, TResult>) => GetAllBookmarksResult<TVersion, TMethod, unknown, TResult>;
 export default getAllBookmarks;

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

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

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

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

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

@@ -1,5 +1,6 @@
 import { ApiBookmarkEntityV1 } from '../api-models';
 import { ClientMethod } from '../types';
+/**Gets result type for GetAllBookmark call based on version and method */
 export type GetAllBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = GetAllBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
 export type GetAllBookmarkResult<TVersion extends ApiVersions, TPayload> = GetAllBookmarksVersions<TPayload>[TVersion]['result'];
 export type GetAllBookmarksVersions<TPayload = unknown> = {

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { PatchBookmarkArgs, PatchBookmarkResult, PatchBookmarksResult } from './types';
-export declare const patchBookmark: <TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PatchBookmarkResult<TVersion, unknown>>(args: PatchBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PatchBookmarksResult<TVersion, TMethod, unknown, TResult>;
+import { ApiVersions, PatchBookmarkArgs, PatchBookmarkResult, PatchBookmarksResult } from './types';
+/**
+ * Method for updating bookmark
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const patchBookmark: <TClient extends IHttpClient = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TVersion extends ApiVersions = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PatchBookmarkResult<TVersion, unknown>>(args: PatchBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PatchBookmarksResult<TVersion, TMethod, unknown, TResult>;
 export default patchBookmark;

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

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

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

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

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

@@ -4,7 +4,9 @@ import { ClientMethod } from '../..';
 import { ApiBookmarkEntityV1 } from '../api-models';
 import { PostBookmarksArgsV1 } from '../post';
 export type PatchBookmarkResult<TVersion extends ApiVersions, TPayload> = PatchBookmarksVersions<TPayload>[TVersion]['result'];
+/** Returns args for PutBookmark based on version*/
 export type PatchBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PatchBookmarksVersions<TPayload>[TVersion]['args'];
+/**Gets result type for PutBookmark call based on version and method */
 export type PatchBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = PatchBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
 export type PatchBookmarkFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = PatchBookmarkResult<TVersion, TPayload>> = (args: PatchBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PatchBookmarksResult<TVersion, TMethod, TPayload, TResult>;
 export interface PatchBookmarksArgsV1<T = unknown> extends Partial<PostBookmarksArgsV1<T>> {

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

@@ -1,5 +1,11 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { PostBookmarkArgs, PostBookmarkResult, PostBookmarksResult } from './types';
-export declare const postBookmark: <TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PostBookmarkResult<TVersion, unknown>>(args: PostBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksResult<TVersion, TMethod, unknown, TResult>;
+import { ApiVersions, PostBookmarkArgs, PostBookmarkResult, PostBookmarksResult } from './types';
+/**
+ * Method for fetching bookmark by it`s id from bookmark service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const postBookmark: <TVersion extends ApiVersions = "v1", 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) => <TResult = PostBookmarkResult<TVersion, unknown>>(args: PostBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksResult<TVersion, TMethod, unknown, TResult>;
 export default postBookmark;

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

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

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

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

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

@@ -3,15 +3,21 @@ import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client'
 import { ClientMethod } from '../..';
 import { ApiBookmarkEntityV1 } from '../api-models';
 export type PostBookmarkResult<TVersion extends ApiVersions, TPayload> = PostBookmarksVersions<TPayload>[TVersion]['result'];
+/** Returns args for GetBookmark based on version*/
 export type PostBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PostBookmarksVersions<TPayload>[TVersion]['args'];
+/**Gets result type for GetBookmark call based on version and method */
 export type PostBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = PostBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
 export type PostBookmarkFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = PostBookmarkResult<TVersion, TPayload>> = (args: PostBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PostBookmarksResult<TVersion, TMethod, TPayload, TResult>;
 export interface PostBookmarksArgsV1<T = unknown> {
+    /** Display name of the bookmark */
     name: string;
     description?: string;
+    /** Is the bookmark shared with others */
     isShared: boolean;
+    /** Name of the app it belongs too, should correspond to a fusion appkey */
     appKey: string;
     contextId?: string;
+    /** Any JSON object to store as the bookmark payload */
     payload: T;
     sourceSystem?: {
         identifier?: string;

package/dist/types/configurator.d.ts

@@ -1,5 +1,6 @@
 import { ApiClientFactory } from './types';
 export interface IApiConfigurator {
+    /** Method for creating IHttpClients */
     createClient?: ApiClientFactory;
 }
 export declare class ApiConfigurator implements IApiConfigurator {

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

@@ -17,6 +17,7 @@ type ApiContextEntityTypes = {
     [ApiVersion.v2]: ApiContextEntity_v2;
 };
 export type ApiContextEntity<T extends string = ApiVersion> = T extends ApiVersion ? ApiContextEntityTypes[T] : unknown;
+/** === types === */
 type ApiContextType_v1 = {
     id: string;
     isChildType: boolean;

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

@@ -9,8 +9,20 @@ export declare class ContextApiClient<TMethod extends keyof ClientMethod<unknown
     protected _method: TMethod;
     get Version(): typeof ApiVersion;
     constructor(_client: TClient, _method: TMethod);
+    /**
+     * Fetch context by id
+     * @see {@link get/client}
+     */
     get<TVersion extends string = keyof typeof ApiVersion, TResult = GetContextResponse<TVersion>>(version: TVersion, ...args: Parameters<GetContextFn<TVersion, TMethod, TClient, TResult>>): GetContextResult<TVersion, TMethod, TResult>;
+    /**
+     * Query context service
+     * @see {@link query/client}
+     */
     query<TVersion extends string = keyof typeof ApiVersion, TResult = QueryContextResponse<TVersion>>(version: TVersion, ...args: Parameters<QueryContextFn<TVersion, TMethod, TClient, TResult>>): QueryContextResult<TVersion, TMethod, TResult>;
+    /**
+     * Query context service
+     * @see {@link query/client}
+     */
     related<TVersion extends string = keyof typeof ApiVersion, TResult = RelatedContextResponse<TVersion>>(version: TVersion, ...args: Parameters<RelatedContextFn<TVersion, TMethod, TClient, TResult>>): RelatedContextResult<TVersion, TMethod, TResult>;
 }
 export default ContextApiClient;

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

@@ -1,4 +1,10 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult } from './types';
-export declare const getContext: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = GetContextResponse<TVersion>>(args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => GetContextResult<TVersion, TMethod, T>;
+/**
+ * Method for fetching context item from context service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export declare const 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 default getContext;

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

@@ -1,2 +1,5 @@
 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;

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

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

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

@@ -1,4 +1,7 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { QueryContextArgs, QueryContextResponse, QueryContextResult, ClientMethod } from './types';
-export declare const queryContext: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = QueryContextResponse<TVersion>>(args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => QueryContextResult<TVersion, TMethod, T>;
+/**
+ * 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 default queryContext;

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

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

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

@@ -1,4 +1,7 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import type { RelatedContextArgs, RelatedContextResponse, RelatedContextResult, ClientMethod } from './types';
-export declare const relatedContexts: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod = keyof ClientMethod, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = RelatedContextResponse<TVersion>>(args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, T>) => RelatedContextResult<TVersion, TMethod, T>;
+/**
+ * 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 default relatedContexts;

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

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

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

@@ -13,6 +13,7 @@ export type RelatedContextOdataParameters = {
     filter?: RelatedContextOdataFilter;
 };
 type RelatedContextArgs_v1 = {
+    /** context id */
     id: string;
     query?: string | RelatedContextOdataParameters;
 };

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

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

package/dist/types/module.d.ts

@@ -9,8 +9,23 @@ export type ServicesModule = Module<ServicesModuleKey, IApiProvider, IApiConfigu
     HttpModule,
     ServiceDiscoveryModule
 ]>;
+/**
+ *  Configure http-client
+ */
 export declare const module: ServicesModule;
+/**
+ * Method for enabling the Service module
+ * @param config - configuration object
+ */
 export declare const enableServices: (config: IModulesConfigurator<any, any>) => void;
+/**
+ * @example
+ * ```ts
+ * config.addConfig(x => x.createClient(...));
+ * ```
+ * @param configure - Callback for configuring the module
+ * @returns Configuration object
+ */
 export declare const configureServices: (configure: (configurator: IApiConfigurator) => void) => IModuleConfigurator<ServicesModule>;
 declare module '@equinor/fusion-framework-module' {
     interface Modules {