@equinor/fusion-framework-module-services 5.1.1-msal-6cf764b628c2afdd64dfd06e42abc953d78556d2 → 5.1.1

package/src/bookmarks/endpoints/bookmark.patch.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 
 import type {
-    ClientRequestInit,
-    FetchRequestInit,
-    IHttpClient,
-    JsonRequest,
+  ClientRequestInit,
+  FetchRequestInit,
+  IHttpClient,
+  JsonRequest,
 } from '@equinor/fusion-framework-module-http/client';
 
 import type { ClientMethod, ExtractApiVersion, FilterAllowedApiVersions } from '../types';
@@ -21,115 +21,115 @@ type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
 
 /** Schema for the input arguments to this operation. */
 const ArgSchema = {
-    [ApiVersion.v1]: z.object({
-        bookmarkId: z.string(),
-        updates: z.object({
-            name: z.string().nullish(),
-            description: z.string().nullish(),
-            isShared: z.boolean().nullish(),
-            payload: z
-                .record(z.unknown())
-                .or(z.string())
-                .nullish()
-                .transform((x) => (typeof x === 'object' ? JSON.stringify(x) : x)),
-            sourceSystem: z
-                .object({
-                    identifier: z.string().nullish(),
-                    name: z.string().nullish(),
-                    subSystem: z.string().nullish(),
-                })
-                .nullish(),
-        }),
+  [ApiVersion.v1]: z.object({
+    bookmarkId: z.string(),
+    updates: z.object({
+      name: z.string().nullish(),
+      description: z.string().nullish(),
+      isShared: z.boolean().nullish(),
+      payload: z
+        .record(z.unknown())
+        .or(z.string())
+        .nullish()
+        .transform((x) => (typeof x === 'object' ? JSON.stringify(x) : x)),
+      sourceSystem: z
+        .object({
+          identifier: z.string().nullish(),
+          name: z.string().nullish(),
+          subSystem: z.string().nullish(),
+        })
+        .nullish(),
     }),
+  }),
 };
 
 /** Schema for the response from the API. */
 const ApiResponseSchema = {
-    [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1].and(
-        z.object({
-            payload: ApiBookmarkPayload[ApiVersion.v1].optional(),
-        }),
-    ),
+  [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1].and(
+    z.object({
+      payload: ApiBookmarkPayload[ApiVersion.v1].optional(),
+    }),
+  ),
 };
 
 /** Defines the expected output from the api. */
 type ApiResponse<TVersion extends AllowedVersions> = z.infer<
-    (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
+  (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
 >;
 
 /** Defines the input arguments to this operation. */
 type MethodArg<TVersion extends AllowedVersions> = z.input<
-    (typeof ArgSchema)[ExtractApiVersion<TVersion>]
+  (typeof ArgSchema)[ExtractApiVersion<TVersion>]
 >;
 
 /** Defines the expected output of this operation. */
 type MethodResult<
-    TVersion extends AllowedVersions,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TResult = ApiResponse<TVersion>,
+  TVersion extends AllowedVersions,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = ApiResponse<TVersion>,
 > = ClientMethod<TResult>[TMethod];
 
 /** utility function for generating http request initialization parameters  */
 const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
-    version: TVersion,
-    args: z.infer<(typeof ArgSchema)[TVersion]>,
-    init?: ClientRequestInit<IHttpClient, TResult>,
+  version: TVersion,
+  args: z.infer<(typeof ArgSchema)[TVersion]>,
+  init?: ClientRequestInit<IHttpClient, TResult>,
 ): ClientRequestInit<IHttpClient, TResult> => {
-    switch (version) {
-        case ApiVersion.v1: {
-            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
-                method: 'PATCH',
-                selector: schemaSelector(ApiResponseSchema[version]),
-                body: args.updates,
-            };
-            return Object.assign({}, baseInit, init);
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+        method: 'PATCH',
+        selector: schemaSelector(ApiResponseSchema[version]),
+        body: args.updates,
+      };
+      return Object.assign({}, baseInit, init);
     }
-    throw Error(`Unknown API version: ${version}`);
+  }
+  throw Error(`Unknown API version: ${version}`);
 };
 
 /** utility function for generating the api path */
 const generateApiPath = <TVersion extends AvailableVersions>(
-    version: TVersion,
-    args: z.infer<(typeof ArgSchema)[TVersion]>,
+  version: TVersion,
+  args: z.infer<(typeof ArgSchema)[TVersion]>,
 ): string => {
-    switch (version) {
-        case ApiVersion.v1: {
-            const params = new URLSearchParams();
-            params.append('api-version', version);
-            return `/bookmarks/${args.bookmarkId}?${String(params)}`;
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const params = new URLSearchParams();
+      params.append('api-version', version);
+      return `/bookmarks/${args.bookmarkId}?${String(params)}`;
     }
-    throw Error(`Unknown API version: ${version}`);
+  }
+  throw Error(`Unknown API version: ${version}`);
 };
 
 /** executes the api call */
 const executeApiCall = <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(
-    version: TVersion,
-    client: IHttpClient,
-    method: TMethod = 'json' as TMethod,
+  version: TVersion,
+  client: IHttpClient,
+  method: TMethod = 'json' as TMethod,
 ) => {
-    type MethodVersion = ExtractApiVersion<TVersion>;
-    const apiVersion = extractVersion(ApiVersion, version);
-    return <
-        TResponse = ApiResponse<MethodVersion>,
-        TResult = MethodResult<MethodVersion, TMethod, TResponse>,
-    >(
-        input: MethodArg<MethodVersion>,
-        init?: ClientRequestInit<IHttpClient, TResponse>,
-    ): TResult => {
-        const args = ArgSchema[apiVersion].parse(input);
-        return client[method](
-            generateApiPath(apiVersion, args),
-            generateRequestParameters(apiVersion, args, init),
-        ) as TResult;
-    };
+  type MethodVersion = ExtractApiVersion<TVersion>;
+  const apiVersion = extractVersion(ApiVersion, version);
+  return <
+    TResponse = ApiResponse<MethodVersion>,
+    TResult = MethodResult<MethodVersion, TMethod, TResponse>,
+  >(
+    input: MethodArg<MethodVersion>,
+    init?: ClientRequestInit<IHttpClient, TResponse>,
+  ): TResult => {
+    const args = ArgSchema[apiVersion].parse(input);
+    return client[method](
+      generateApiPath(apiVersion, args),
+      generateRequestParameters(apiVersion, args, init),
+    ) as TResult;
+  };
 };
 
 export {
-    AllowedVersions as PatchBookmarkVersion,
-    MethodArg as PatchBookmarkArg,
-    ApiResponse as PatchBookmarkResponse,
-    MethodResult as PatchBookmarksResult,
-    executeApiCall as patchBookmark,
+  type AllowedVersions as PatchBookmarkVersion,
+  type MethodArg as PatchBookmarkArg,
+  type ApiResponse as PatchBookmarkResponse,
+  type MethodResult as PatchBookmarksResult,
+  executeApiCall as patchBookmark,
 };

package/src/bookmarks/endpoints/bookmark.post.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 
 import type {
-    ClientRequestInit,
-    FetchRequestInit,
-    IHttpClient,
-    JsonRequest,
+  ClientRequestInit,
+  FetchRequestInit,
+  IHttpClient,
+  JsonRequest,
 } from '@equinor/fusion-framework-module-http/client';
 
 import type { ClientMethod, ExtractApiVersion, FilterAllowedApiVersions } from '../types';
@@ -21,104 +21,104 @@ type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
 
 /** Schema for the input arguments to this operation. */
 const ArgSchema = {
-    [ApiVersion.v1]: z.object({
-        name: z.string(),
-        appKey: z.string(),
-        payload: z.record(z.unknown()).or(z.string()).optional(),
-        description: z.string().nullish(),
-        isShared: z.boolean().nullish(),
-        contextId: z.string().nullish(),
-        sourceSystem: ApiSourceSystem[ApiVersion.v1].nullish(),
-    }),
+  [ApiVersion.v1]: z.object({
+    name: z.string(),
+    appKey: z.string(),
+    payload: z.record(z.unknown()).or(z.string()).optional(),
+    description: z.string().nullish(),
+    isShared: z.boolean().nullish(),
+    contextId: z.string().nullish(),
+    sourceSystem: ApiSourceSystem[ApiVersion.v1].nullish(),
+  }),
 };
 
 /** Schema for the response from the API. */
 const ApiResponseSchema = {
-    [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1].and(
-        z.object({
-            payload: ApiBookmarkPayload[ApiVersion.v1].optional(),
-        }),
-    ),
+  [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1].and(
+    z.object({
+      payload: ApiBookmarkPayload[ApiVersion.v1].optional(),
+    }),
+  ),
 };
 
 /** Defines the expected output from the api. */
 type ApiResponse<TVersion extends AllowedVersions> = z.infer<
-    (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
+  (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
 >;
 
 /** Defines the input arguments to this operation. */
 type MethodArg<TVersion extends AllowedVersions> = z.input<
-    (typeof ArgSchema)[ExtractApiVersion<TVersion>]
+  (typeof ArgSchema)[ExtractApiVersion<TVersion>]
 >;
 
 /** Defines the expected output of this operation. */
 type MethodResult<
-    TVersion extends AllowedVersions,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TResult = ApiResponse<TVersion>,
+  TVersion extends AllowedVersions,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = ApiResponse<TVersion>,
 > = ClientMethod<TResult>[TMethod];
 
 /** utility function for generating http request initialization parameters  */
 const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
-    version: TVersion,
-    args: z.infer<(typeof ArgSchema)[TVersion]>,
-    init?: ClientRequestInit<IHttpClient, TResult>,
+  version: TVersion,
+  args: z.infer<(typeof ArgSchema)[TVersion]>,
+  init?: ClientRequestInit<IHttpClient, TResult>,
 ): ClientRequestInit<IHttpClient, TResult> => {
-    switch (version) {
-        case ApiVersion.v1: {
-            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
-                method: 'POST',
-                selector: schemaSelector(ApiResponseSchema[version]),
-                body: args,
-            };
-            return Object.assign({}, baseInit, init);
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+        method: 'POST',
+        selector: schemaSelector(ApiResponseSchema[version]),
+        body: args,
+      };
+      return Object.assign({}, baseInit, init);
     }
-    throw Error(`Unknown API version: ${version}`);
+  }
+  throw Error(`Unknown API version: ${version}`);
 };
 
 /** utility function for generating the api path */
 const generateApiPath = <TVersion extends AvailableVersions>(
-    version: TVersion,
-    _args: z.infer<(typeof ArgSchema)[TVersion]>,
+  version: TVersion,
+  _args: z.infer<(typeof ArgSchema)[TVersion]>,
 ): string => {
-    switch (version) {
-        case ApiVersion.v1: {
-            const params = new URLSearchParams();
-            params.append('api-version', version);
-            return `/bookmarks?${String(params)}`;
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const params = new URLSearchParams();
+      params.append('api-version', version);
+      return `/bookmarks?${String(params)}`;
     }
-    throw Error(`Unknown API version: ${version}`);
+  }
+  throw Error(`Unknown API version: ${version}`);
 };
 
 /** executes the api call */
 const executeApiCall = <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(
-    version: TVersion,
-    client: IHttpClient,
-    method: TMethod = 'json' as TMethod,
+  version: TVersion,
+  client: IHttpClient,
+  method: TMethod = 'json' as TMethod,
 ) => {
-    type MethodVersion = ExtractApiVersion<TVersion>;
-    const apiVersion = extractVersion(ApiVersion, version);
-    return <
-        TResponse = ApiResponse<MethodVersion>,
-        TResult = MethodResult<MethodVersion, TMethod, TResponse>,
-    >(
-        input: MethodArg<MethodVersion>,
-        init?: ClientRequestInit<IHttpClient, TResponse>,
-    ): TResult => {
-        const args = ArgSchema[apiVersion].parse(input);
-        return client[method](
-            generateApiPath(apiVersion, args),
-            generateRequestParameters(apiVersion, args, init),
-        ) as TResult;
-    };
+  type MethodVersion = ExtractApiVersion<TVersion>;
+  const apiVersion = extractVersion(ApiVersion, version);
+  return <
+    TResponse = ApiResponse<MethodVersion>,
+    TResult = MethodResult<MethodVersion, TMethod, TResponse>,
+  >(
+    input: MethodArg<MethodVersion>,
+    init?: ClientRequestInit<IHttpClient, TResponse>,
+  ): TResult => {
+    const args = ArgSchema[apiVersion].parse(input);
+    return client[method](
+      generateApiPath(apiVersion, args),
+      generateRequestParameters(apiVersion, args, init),
+    ) as TResult;
+  };
 };
 
 export {
-    AllowedVersions as CreateBookmarkVersion,
-    MethodArg as CreateBookmarkArg,
-    ApiResponse as CreateBookmarkResponse,
-    MethodResult as CreateBookmarksResult,
-    executeApiCall as createBookmark,
+  type AllowedVersions as CreateBookmarkVersion,
+  type MethodArg as CreateBookmarkArg,
+  type ApiResponse as CreateBookmarkResponse,
+  type MethodResult as CreateBookmarksResult,
+  executeApiCall as createBookmark,
 };

package/src/bookmarks/endpoints/user-bookmark-favourite.delete.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 
 import type {
-    ClientRequestInit,
-    FetchRequestInit,
-    IHttpClient,
-    JsonRequest,
+  ClientRequestInit,
+  FetchRequestInit,
+  IHttpClient,
+  JsonRequest,
 } from '@equinor/fusion-framework-module-http/client';
 
 import type { ClientMethod, ExtractApiVersion, FilterAllowedApiVersions } from '../types';
@@ -21,93 +21,93 @@ type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
 
 /** Schema for the input arguments to this operation. */
 const ArgSchema = {
-    [ApiVersion.v1]: z.object({
-        bookmarkId: z.string(),
-    }),
+  [ApiVersion.v1]: z.object({
+    bookmarkId: z.string(),
+  }),
 };
 
 /** Schema for the response from the API. */
 const ApiResponseSchema = {
-    [ApiVersion.v1]: z.boolean(),
+  [ApiVersion.v1]: z.boolean(),
 };
 
 /** Defines the expected output from the api. */
 type ApiResponse<TVersion extends AllowedVersions> = z.infer<
-    (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
+  (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
 >;
 
 /** Defines the input arguments to this operation. */
 type MethodArg<TVersion extends AllowedVersions> = z.input<
-    (typeof ArgSchema)[ExtractApiVersion<TVersion>]
+  (typeof ArgSchema)[ExtractApiVersion<TVersion>]
 >;
 
 /** Defines the expected output of this operation. */
 type MethodResult<
-    TVersion extends AllowedVersions,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TResult = ApiResponse<TVersion>,
+  TVersion extends AllowedVersions,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = ApiResponse<TVersion>,
 > = ClientMethod<TResult>[TMethod];
 
 /** utility function for generating http request initialization parameters  */
 const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
-    version: TVersion,
-    args: z.infer<(typeof ArgSchema)[TVersion]>,
-    init?: ClientRequestInit<IHttpClient, TResult>,
+  version: TVersion,
+  args: z.infer<(typeof ArgSchema)[TVersion]>,
+  init?: ClientRequestInit<IHttpClient, TResult>,
 ): ClientRequestInit<IHttpClient, TResult> => {
-    switch (version) {
-        case ApiVersion.v1: {
-            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
-                method: 'DELETE',
-                selector: statusSelector,
-            };
-            return Object.assign({}, baseInit, init);
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+        method: 'DELETE',
+        selector: statusSelector,
+      };
+      return Object.assign({}, baseInit, init);
     }
-    throw Error(`Unknown API version: ${version}`);
+  }
+  throw Error(`Unknown API version: ${version}`);
 };
 
 /** utility function for generating the api path */
 const generateApiPath = <TVersion extends AvailableVersions>(
-    version: TVersion,
-    args: z.infer<(typeof ArgSchema)[TVersion]>,
+  version: TVersion,
+  args: z.infer<(typeof ArgSchema)[TVersion]>,
 ): string => {
-    switch (version) {
-        case ApiVersion.v1: {
-            const params = new URLSearchParams();
-            params.append('api-version', version);
-            return `/persons/me/bookmarks/favourites/${args.bookmarkId}?${String(params)}`;
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const params = new URLSearchParams();
+      params.append('api-version', version);
+      return `/persons/me/bookmarks/favourites/${args.bookmarkId}?${String(params)}`;
     }
-    throw Error(`Unknown API version: ${version}`);
+  }
+  throw Error(`Unknown API version: ${version}`);
 };
 
 /** executes the api call */
 const executeApiCall = <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(
-    version: TVersion,
-    client: IHttpClient,
-    method: TMethod = 'json' as TMethod,
+  version: TVersion,
+  client: IHttpClient,
+  method: TMethod = 'json' as TMethod,
 ) => {
-    type MethodVersion = ExtractApiVersion<TVersion>;
-    const apiVersion = extractVersion(ApiVersion, version);
-    return <
-        TResponse = ApiResponse<MethodVersion>,
-        TResult = MethodResult<MethodVersion, TMethod, TResponse>,
-    >(
-        input: MethodArg<MethodVersion>,
-        init?: ClientRequestInit<IHttpClient, TResponse>,
-    ): TResult => {
-        const args = ArgSchema[apiVersion].parse(input);
-        return client[method](
-            generateApiPath(apiVersion, args),
-            generateRequestParameters(apiVersion, args, init),
-        ) as TResult;
-    };
+  type MethodVersion = ExtractApiVersion<TVersion>;
+  const apiVersion = extractVersion(ApiVersion, version);
+  return <
+    TResponse = ApiResponse<MethodVersion>,
+    TResult = MethodResult<MethodVersion, TMethod, TResponse>,
+  >(
+    input: MethodArg<MethodVersion>,
+    init?: ClientRequestInit<IHttpClient, TResponse>,
+  ): TResult => {
+    const args = ArgSchema[apiVersion].parse(input);
+    return client[method](
+      generateApiPath(apiVersion, args),
+      generateRequestParameters(apiVersion, args, init),
+    ) as TResult;
+  };
 };
 
 export {
-    AllowedVersions as RemoveBookmarkFavouriteVersion,
-    MethodArg as RemoveBookmarkFavouriteArgs,
-    ApiResponse as RemoveBookmarkFavouriteResponse,
-    MethodResult as RemoveBookmarkFavouriteResult,
-    executeApiCall as removeFavoriteBookmark,
+  type AllowedVersions as RemoveBookmarkFavouriteVersion,
+  type MethodArg as RemoveBookmarkFavouriteArgs,
+  type ApiResponse as RemoveBookmarkFavouriteResponse,
+  type MethodResult as RemoveBookmarkFavouriteResult,
+  executeApiCall as removeFavoriteBookmark,
 };