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

package/src/bookmarks/endpoints/bookmark-apply.get.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,94 +21,94 @@ 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.object({
-        id: z.string(),
-        payload: ApiBookmarkPayload[ApiVersion.v1],
-    }),
+  [ApiVersion.v1]: z.object({
+    id: z.string(),
+    payload: ApiBookmarkPayload[ApiVersion.v1],
+  }),
 };
 
 /** 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: 'GET',
-                selector: schemaSelector(ApiResponseSchema[version]),
-            };
-            return Object.assign({}, baseInit, init);
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+        method: 'GET',
+        selector: schemaSelector(ApiResponseSchema[version]),
+      };
+      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}/apply?${String(params)}`;
-        }
+  switch (version) {
+    case ApiVersion.v1: {
+      const params = new URLSearchParams();
+      params.append('api-version', version);
+      return `/bookmarks/${args.bookmarkId}/apply?${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 BookmarkApplyVersion,
-    MethodArg as BookmarkApplyArgs,
-    ApiResponse as BookmarkApplyResponse,
-    MethodResult as BookmarkApplyResult,
-    executeApiCall as getBookmarkApply,
+  type AllowedVersions as BookmarkApplyVersion,
+  type MethodArg as BookmarkApplyArgs,
+  type ApiResponse as BookmarkApplyResponse,
+  type MethodResult as BookmarkApplyResult,
+  executeApiCall as getBookmarkApply,
 };

package/src/bookmarks/endpoints/bookmark.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 `/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 DeleteBookmarkVersion,
-    MethodArg as DeleteBookmarkArg,
-    ApiResponse as DeleteBookmarkResponse,
-    MethodResult as DeleteBookmarksResult,
-    executeApiCall as deleteBookmark,
+  type AllowedVersions as DeleteBookmarkVersion,
+  type MethodArg as DeleteBookmarkArg,
+  type ApiResponse as DeleteBookmarkResponse,
+  type MethodResult as DeleteBookmarksResult,
+  executeApiCall as deleteBookmark,
 };

package/src/bookmarks/endpoints/bookmark.get.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,98 +21,98 @@ type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
 
 /** Schema for the input arguments to this operation. */
 const ArgSchema = {
-    [ApiVersion.v1]: z.object({
-        bookmarkId: z.string(),
-    }),
-    [ApiVersion.v2]: z.object({
-        bookmarkId: z.string(),
-    }),
+  [ApiVersion.v1]: z.object({
+    bookmarkId: z.string(),
+  }),
+  [ApiVersion.v2]: z.object({
+    bookmarkId: z.string(),
+  }),
 };
 
 /** Schema for the response from the API. */
 const ApiResponseSchema = {
-    [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1],
-    [ApiVersion.v2]: ApiBookmarkSchema[ApiVersion.v2],
+  [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1],
+  [ApiVersion.v2]: ApiBookmarkSchema[ApiVersion.v2],
 };
 
 /** 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:
-        case ApiVersion.v2: {
-            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
-                selector: schemaSelector(ApiResponseSchema[version]),
-            };
-            return Object.assign({}, baseInit, init);
-        }
+  switch (version) {
+    case ApiVersion.v1:
+    case ApiVersion.v2: {
+      const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+        selector: schemaSelector(ApiResponseSchema[version]),
+      };
+      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:
-        case ApiVersion.v2: {
-            const params = new URLSearchParams();
-            params.append('api-version', version);
-            return `/bookmarks/${args.bookmarkId}?${String(params)}`;
-        }
+  switch (version) {
+    case ApiVersion.v1:
+    case ApiVersion.v2: {
+      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 GetBookmarkVersion,
-    MethodArg as GetBookmarkArg,
-    ApiResponse as GetBookmarkResponse,
-    MethodResult as GetBookmarkResult,
-    executeApiCall as getBookmark,
+  type AllowedVersions as GetBookmarkVersion,
+  type MethodArg as GetBookmarkArg,
+  type ApiResponse as GetBookmarkResponse,
+  type MethodResult as GetBookmarkResult,
+  executeApiCall as getBookmark,
 };