@envive-ai/react-hooks 0.2.10 → 0.3.0

package/src/application/commerce-api.ts

@@ -1,4 +1,4 @@
-import Logger from "src/application/logging/logger";
+import Logger from 'src/application/logging/logger';
 import {
   Configuration,
   CustomerServiceApi,
@@ -14,14 +14,14 @@ import {
   CustomerServiceProvider,
   ResponseCategory,
   FormType,
-} from "@spiffy-ai/commerce-api-client";
-import { validateSuggestion } from "src/application/models/validators/validateSuggestion";
-import { validateUserEvent } from "src/application/models/validators/validateUserEvent";
+} from '@spiffy-ai/commerce-api-client';
+import { validateSuggestion } from 'src/application/models/validators/validateSuggestion';
+import { validateUserEvent } from 'src/application/models/validators/validateUserEvent';
 import {
   messageFromQueryEvent,
   messageFromResponse,
   messageFromSuggestionEvent,
-} from "src/application/utils";
+} from 'src/application/utils';
 import {
   Message,
   NextMessageRequest,
@@ -29,31 +29,31 @@ import {
   Suggestion,
   SupportedEventRequest,
   UserEvent,
-} from "src/application/models";
-import { messageRequestToCommerceMessageRequest } from "src/application/utils/nextMessageRequestToApiRequest";
-import { validateResponse } from "src/application/models/validators/validateResponse";
-import { coreSupportedEventRequestToApiRequest } from "src/application/utils/supportedEventRequestToApiRequest";
-import { SessionRestartRequired } from "src/types/exceptions/sessionExceptions";
-import { UnsupportedProductException } from "src/types/exceptions/unsupportedProductExceptions";
-import { ClientDetails } from "src/application/models/clientDetails";
-import { getAtomStore } from "src/atoms/atomStore/atomStore";
-import { ProductExperiment } from "src/application/models/productExperiment";
-import { FeatureGates } from "src/application/models/featureGates";
-import { validateOrgConfigResults } from "src/application/models/validators/validateOrgConfigResults";
-import { OrgConfig } from "src/application/models/api/orgConfigResults";
-import { SupportedEvent } from "src/atoms/app/variant";
-import { messageFromFormSubmittedEvent } from "src/application/utils/messageFromFormSubmittedEvent";
-import type { Context } from "@spiffy-ai/commerce-api-client/dist/models/Context";
-import { ContextEnvEnum } from "@spiffy-ai/commerce-api-client"; // Import ContextEnvEnum
+} from 'src/application/models';
+import { messageRequestToCommerceMessageRequest } from 'src/application/utils/nextMessageRequestToApiRequest';
+import { validateResponse } from 'src/application/models/validators/validateResponse';
+import { coreSupportedEventRequestToApiRequest } from 'src/application/utils/supportedEventRequestToApiRequest';
+import { SessionRestartRequired } from 'src/types/exceptions/sessionExceptions';
+import { UnsupportedProductException } from 'src/types/exceptions/unsupportedProductExceptions';
+import { ClientDetails } from 'src/application/models/clientDetails';
+import { getAtomStore } from 'src/atoms/atomStore/atomStore';
+import { ProductExperiment } from 'src/application/models/productExperiment';
+import { FeatureGates } from 'src/application/models/featureGates';
+import { validateOrgConfigResults } from 'src/application/models/validators/validateOrgConfigResults';
+import { OrgConfig } from 'src/application/models/api/orgConfigResults';
+import { SupportedEvent } from 'src/atoms/app/variant';
+import { messageFromFormSubmittedEvent } from 'src/application/utils/messageFromFormSubmittedEvent';
+import type { Context } from '@spiffy-ai/commerce-api-client/dist/models/Context';
+import { ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import ContextEnvEnum
 import {
   baseUrlAtom,
   reactAppNameAtom,
   contextSourceAtom,
   orgShortNameAtom,
   envAtom, // Import envAtom
-} from "src/atoms/envive/enviveConfig";
-import { userIdAtom, chatIdAtom } from "src/atoms/app"; // Import userIdAtom and chatIdAtom
-import { orgIdAtom, featureFlagServiceAtom } from "src/atoms/org/graphqlConfig"; // Import new orgIdAtom and featureFlagServiceAtom
+} from 'src/atoms/envive/enviveConfig';
+import { userIdAtom, chatIdAtom } from 'src/atoms/app'; // Import userIdAtom and chatIdAtom
+import { orgIdAtom, featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig'; // Import new orgIdAtom and featureFlagServiceAtom
 
 async function errorResponseBody(error: ResponseError) {
   try {
@@ -71,19 +71,19 @@ async function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {
 
   const errorResponse = await errorResponseBody(error);
   if (
-    errorResponse?.message?.toLowerCase() === "unsupported product" || // for backward compatibility. newer versions of the API return sub_code instead of message
-    errorResponse?.app_code?.toUpperCase() === "PRODUCT_NOT_FOUND"
+    errorResponse?.message?.toLowerCase() === 'unsupported product' || // for backward compatibility. newer versions of the API return sub_code instead of message
+    errorResponse?.app_code?.toUpperCase() === 'PRODUCT_NOT_FOUND'
   ) {
     throw new UnsupportedProductException();
   } else if (
-    errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" ||
-    errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND" // for backward compatibility. new API responses will contain "app_code"
+    errorResponse?.app_code?.toUpperCase() === 'RESTART_SESSION' ||
+    errorResponse?.sub_code?.toUpperCase() === 'NOT_FOUND' // for backward compatibility. new API responses will contain "app_code"
   ) {
     Logger.logInfo(
-      "Session does not exist. Re-start session",
+      'Session does not exist. Re-start session',
       error,
       error.response,
-      errorResponse
+      errorResponse,
     );
     throw new SessionRestartRequired();
   }
@@ -121,8 +121,8 @@ class CommerceApiClient {
     const config: Configuration = new Configuration({
       basePath: path,
       headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
       },
     });
     this.defaultApi = new DefaultApi(config);
@@ -142,103 +142,87 @@ class CommerceApiClient {
     const featureFlagService = atomStore.get(featureFlagServiceAtom);
 
     const context: Context = {
-      user_id: userId ?? "",
-      org_id: orgId ?? "",
-      org_short_name: orgShortName ?? "",
-      chat_id: chatId ?? "",
+      user_id: userId ?? '',
+      org_id: orgId ?? '',
+      org_short_name: orgShortName ?? '',
+      chat_id: chatId ?? '',
       source: source ?? ContextSourceEnum.App,
       env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev, // Cast env to ContextEnvEnum
     };
 
-    const featureGates =
-      featureFlagService?.featureFlagService?.getFeatureFlags() || {};
+    const featureGates = featureFlagService?.featureFlagService?.getFeatureFlags() || {};
     const urlResolvingRequest = {
       url,
       context,
       feature_gates: featureGates,
     };
 
-    const rawResponse =
-      await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({
-        UrlResolvingRequest: urlResolvingRequest,
-      });
+    const rawResponse = await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({
+      UrlResolvingRequest: urlResolvingRequest,
+    });
 
     const responseBody = await rawResponse.raw.json();
 
     return responseBody;
   };
 
-  static reportSession = async (
-    reportRequest: ReportSessionRequest
-  ): Promise<void> => {
-    await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost(
-      {
-        ReportSessionRequest: reportRequest,
-      }
-    );
+  static reportSession = async (reportRequest: ReportSessionRequest): Promise<void> => {
+    await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost({
+      ReportSessionRequest: reportRequest,
+    });
   };
 
-  static getNextResponses = async (
-    payload: NextMessageRequest
-  ): Promise<Message[]> => {
+  static getNextResponses = async (payload: NextMessageRequest): Promise<Message[]> => {
     try {
-      const response =
-        await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({
-          NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
-        });
+      const response = await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({
+        NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
+      });
       const messages = response
-        .map((resp) => validateResponse(resp))
-        .map((resp) => messageFromResponse(resp));
+        .map(resp => validateResponse(resp))
+        .map(resp => messageFromResponse(resp));
 
       return messages.filter((m): m is Message => m != null);
     } catch (err: unknown) {
-      Logger.logInfo("Failed to get next responses", err, {
+      Logger.logInfo('Failed to get next responses', err, {
         payloadContext: payload?.context,
         userEvents: payload?.userEvents,
       });
-      await throwSessionRestartRequiredIf("Failed to get next responses", err);
+      await throwSessionRestartRequiredIf('Failed to get next responses', err);
       return [];
     }
   };
 
   static getNextResponseStreaming = (
-    payload: NextMessageRequest
+    payload: NextMessageRequest,
   ): AsyncGenerator<Response, void, unknown> => {
-    async function* generate(
-      inferenceApi: InferenceApi,
-      abortController: AbortController
-    ) {
+    async function* generate(inferenceApi: InferenceApi, abortController: AbortController) {
       // make sure streaming is enabled
       try {
         const response = await inferenceApi.v1NextResponsesPostRaw(
           {
             NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
           },
-          { signal: abortController.signal }
+          { signal: abortController.signal },
         );
 
         // Read the response as a stream of data
         if (!response.raw.body) {
-          Logger.logError(
-            "[spiffy-ai] No body in the streamed response",
-            undefined,
-            {
-              response: response.raw,
-            }
-          );
+          Logger.logError('[spiffy-ai] No body in the streamed response', undefined, {
+            response: response.raw,
+          });
           return;
         }
 
         const reader = response.raw.body.getReader();
-        const decoder = new TextDecoder("utf-8");
+        const decoder = new TextDecoder('utf-8');
 
-        let partial = "";
+        let partial = '';
         // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
         const safeParse = (line: string): unknown => {
           try {
             return JSON.parse(line); // Parse the JSON string
           } catch (err) {
-            Logger.logError("[spiffy-ai] Error parsing streamed line", err, {
+            Logger.logError('[spiffy-ai] Error parsing streamed line', err, {
               line,
               partial,
             });
@@ -251,13 +235,13 @@ class CommerceApiClient {
         // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
         const processChunk = (chunk: string): unknown[] => {
           // merge the partial with the incoming chunk
-          const lines = `${partial}${chunk}`.split("\n");
+          const lines = `${partial}${chunk}`.split('\n');
 
           const parsedLines = lines
-            .map((line) => line.replace(/^data: /, "").trim()) // Remove the "data: " prefix
-            .filter((line) => line !== "" && line !== "[DONE]") // Remove empty lines and "[DONE]"
+            .map(line => line.replace(/^data: /, '').trim()) // Remove the "data: " prefix
+            .filter(line => line !== '' && line !== '[DONE]') // Remove empty lines and "[DONE]"
             .map(safeParse)
-            .filter((v) => v); // and filter out the undefined values
+            .filter(v => v); // and filter out the undefined values
           return parsedLines;
         };
 
@@ -282,62 +266,49 @@ class CommerceApiClient {
           }
         }
       } catch (error: unknown) {
-        Logger.logError(
-          "[spiffy-ai] Failed to get next streaming responses",
-          error,
-          {
-            payloadContext: payload?.context,
-            userEvents: payload?.userEvents,
-          }
-        );
-        await throwSessionRestartRequiredIf(
-          "Failed to get next streaming responses",
-          error
-        );
+        Logger.logError('[spiffy-ai] Failed to get next streaming responses', error, {
+          payloadContext: payload?.context,
+          userEvents: payload?.userEvents,
+        });
+        await throwSessionRestartRequiredIf('Failed to get next streaming responses', error);
       }
     }
 
     CommerceApiClient.getInstance().responsesAbortController.abort();
-    CommerceApiClient.getInstance().responsesAbortController =
-      new AbortController();
+    CommerceApiClient.getInstance().responsesAbortController = new AbortController();
 
     return generate(
       CommerceApiClient.getInstance().inferenceApi,
-      CommerceApiClient.getInstance().responsesAbortController
+      CommerceApiClient.getInstance().responsesAbortController,
     );
   };
 
-  static getNextSuggestions = async (
-    payload: NextMessageRequest
-  ): Promise<Suggestion[]> => {
+  static getNextSuggestions = async (payload: NextMessageRequest): Promise<Suggestion[]> => {
     try {
       CommerceApiClient.getInstance().suggestionsAbortController.abort();
-      CommerceApiClient.getInstance().suggestionsAbortController =
-        new AbortController();
+      CommerceApiClient.getInstance().suggestionsAbortController = new AbortController();
 
-      const response =
-        await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost(
-          {
-            NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
-          },
-          {
-            signal:
-              CommerceApiClient.getInstance().suggestionsAbortController.signal,
-          }
-        );
+      const response = await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost(
+        {
+          NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
+        },
+        {
+          signal: CommerceApiClient.getInstance().suggestionsAbortController.signal,
+        },
+      );
 
       const suggestions = response
-        .map((resp) => validateSuggestion(resp))
+        .map(resp => validateSuggestion(resp))
         .filter((suggestion): suggestion is Suggestion => suggestion != null);
 
       return suggestions;
     } catch (error: unknown) {
-      Logger.logInfo("Failed to get suggestions", error, {
+      Logger.logInfo('Failed to get suggestions', error, {
         payloadContext: payload?.context,
         userEvents: payload?.userEvents,
       });
 
-      await throwSessionRestartRequiredIf("Failed to get suggestions", error);
+      await throwSessionRestartRequiredIf('Failed to get suggestions', error);
       return [];
     }
   };
@@ -354,7 +325,7 @@ class CommerceApiClient {
   static getResponses = async (
     orgId: string,
     chatId: string,
-    userId: string
+    userId: string,
   ): Promise<{
     responses: Response[][];
     userEvents: UserEvent[];
@@ -372,58 +343,48 @@ class CommerceApiClient {
       user_id: userId,
     };
     try {
-      data =
-        await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(
-          request
-        );
+      data = await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(request);
     } catch (error: unknown) {
-      await throwSessionRestartRequiredIf(
-        "Failed to get chat responses",
-        error
-      );
+      await throwSessionRestartRequiredIf('Failed to get chat responses', error);
     }
 
-    const responses: Response[][] = data?.responses?.map((turn) =>
+    const responses: Response[][] = data?.responses?.map(turn =>
       turn
-        .map((response) => validateResponse(response))
-        .filter((response): response is Response => response != null)
+        .map(response => validateResponse(response))
+        .filter((response): response is Response => response != null),
     );
 
     const suggestions: Suggestion[] = data?.suggestions
-      .map((suggestion) => validateSuggestion(suggestion))
+      .map(suggestion => validateSuggestion(suggestion))
       .filter((suggestion): suggestion is Suggestion => suggestion != null);
 
     const userEvents: UserEvent[] = data?.user_events
-      .map((event) => validateUserEvent(event))
+      .map(event => validateUserEvent(event))
       .filter((event): event is UserEvent => event != null);
 
     // if a form has already been submitted, don't show it in the chat history
     const formSubmittedUserEventsFormIds = userEvents
-      .filter((event) => event.category === UserEventCategory.FormSubmitted)
-      .map((event) => event.attributes.formResponseId);
+      .filter(event => event.category === UserEventCategory.FormSubmitted)
+      .map(event => event.attributes.formResponseId);
 
     const assistantMessages: Message[][] = responses
-      .map((turn) =>
+      .map(turn =>
         turn
           .filter(
-            (response) =>
+            response =>
               !(
                 response.category === ResponseCategory.Form &&
                 formSubmittedUserEventsFormIds.includes(response.id)
-              )
+              ),
           )
-          .map((response) => messageFromResponse(response))
-          .filter((message): message is Message => message != null)
+          .map(response => messageFromResponse(response))
+          .filter((message): message is Message => message != null),
       )
-      .filter((turn) => turn.length > 0);
+      .filter(turn => turn.length > 0);
 
     const userMessages: Message[][] = userEvents
-      .map((event) => {
-        if (
-          [UserEventCategory.QueryTyped, UserEventCategory.Search].includes(
-            event.category
-          )
-        ) {
+      .map(event => {
+        if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) {
           return [messageFromQueryEvent(event)];
         }
 
@@ -435,15 +396,13 @@ class CommerceApiClient {
           const formResponse = responses
             .flat()
             .find(
-              (response) =>
+              response =>
                 response.id === event.attributes.formResponseId &&
-                event.attributes.formType !== FormType.Escalation
+                event.attributes.formType !== FormType.Escalation,
             );
 
           if (formResponse && formResponse.category === ResponseCategory.Form) {
-            return [
-              messageFromFormSubmittedEvent(event, formResponse.attributes),
-            ];
+            return [messageFromFormSubmittedEvent(event, formResponse.attributes)];
           }
         }
 
@@ -453,8 +412,7 @@ class CommerceApiClient {
 
     // Sort the messages chronologically to reconstruct the chat history
     const sortedMessages = [...assistantMessages, ...userMessages].sort(
-      (a, b) =>
-        new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime()
+      (a, b) => new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime(),
     );
 
     return { responses, userEvents, suggestions, messages: sortedMessages };
@@ -465,17 +423,12 @@ class CommerceApiClient {
    * @param payload
    * @returns
    */
-  static isSupportedEvent = async (
-    payload: SupportedEventRequest
-  ): Promise<SupportedEvent> => {
+  static isSupportedEvent = async (payload: SupportedEventRequest): Promise<SupportedEvent> => {
     try {
       const rawResponse =
-        await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw(
-          {
-            SupportedEventRequest:
-              coreSupportedEventRequestToApiRequest(payload),
-          }
-        );
+        await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw({
+          SupportedEventRequest: coreSupportedEventRequestToApiRequest(payload),
+        });
 
       // Get the actual HTTP response JSON
       const httpResponseText = await rawResponse.raw.text();
@@ -487,7 +440,7 @@ class CommerceApiClient {
         merchant_tags: httpResponseJson.merchant_tags || [],
       };
     } catch (err) {
-      Logger.logError("Failed to get response for v1SupportedEventPost", {
+      Logger.logError('Failed to get response for v1SupportedEventPost', {
         err,
       });
       return {
@@ -505,7 +458,7 @@ class CommerceApiClient {
   static identifyUser = async (
     spiffyUserId: string,
     merchantUserId: string,
-    uaDetails: ClientDetails
+    uaDetails: ClientDetails,
   ): Promise<void> => {
     try {
       await CommerceApiClient.getInstance().defaultApi.v1AnalyticsIdentifyPost({
@@ -527,12 +480,12 @@ class CommerceApiClient {
         },
       });
     } catch (err) {
-      Logger.logError("Failed to identify user", err);
+      Logger.logError('Failed to identify user', err);
     }
   };
 
   private static mapContextSourceToV1OrgConfigGetSource = (
-    source: ContextSourceEnum | undefined
+    source: ContextSourceEnum | undefined,
   ): V1OrgConfigGetSourceEnum | undefined => {
     if (source === undefined) return undefined;
     switch (source) {
@@ -554,9 +507,7 @@ class CommerceApiClient {
     }
   };
 
-  static getOrgConfig = async (
-    user_id: string
-  ): Promise<OrgConfig | undefined> => {
+  static getOrgConfig = async (user_id: string): Promise<OrgConfig | undefined> => {
     try {
       const atomStore = getAtomStore();
       const reactAppName = atomStore.get(reactAppNameAtom);
@@ -568,15 +519,12 @@ class CommerceApiClient {
         source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),
         include_experiments: Object.values(ProductExperiment),
         include_feature_gates: Object.entries(
-          featureFlagService?.featureFlagService?.getFeatureFlags() || {}
+          featureFlagService?.featureFlagService?.getFeatureFlags() || {},
         )
           .filter(([, isEnabled]) => isEnabled)
           .map(([featureGateName]) => featureGateName), // Use featureFlagService
       };
-      const response =
-        await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(
-          request
-        );
+      const response = await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request);
 
       return validateOrgConfigResults(response);
     } catch (err) {
@@ -588,10 +536,10 @@ class CommerceApiClient {
   static addNoteToLatestConversation = async (
     spiffyUserId: string,
     email: string,
-    customerServiceProvider: CustomerServiceProvider
+    customerServiceProvider: CustomerServiceProvider,
   ) => {
     Logger.logInfo(
-      `addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`
+      `addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`,
     );
     try {
       await CommerceApiClient.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost(
@@ -601,15 +549,14 @@ class CommerceApiClient {
             email,
             customer_service_provider: customerServiceProvider,
           },
-        }
+        },
       );
     } catch (err) {
-      Logger.logError("Failed to add note to latest conversation", { err });
+      Logger.logError('Failed to add note to latest conversation', { err });
     }
   };
 
-  static getCustomerServiceApi = () =>
-    CommerceApiClient.getInstance().customerServiceApi;
+  static getCustomerServiceApi = () => CommerceApiClient.getInstance().customerServiceApi;
 }
 
 export default CommerceApiClient;

package/src/application/logging/logger.ts

@@ -9,19 +9,11 @@ class Logger {
     console.debug(`DEBUG: ${message}`, ...args);
   }
 
-  static logError(
-    message: string,
-    error: unknown | undefined,
-    ...args: unknown[]
-  ): void {
+  static logError(message: string, error: unknown | undefined, ...args: unknown[]): void {
     console.error(`ERROR: ${message} error=${error}`, args);
   }
 
-  static logWarn(
-    message: string,
-    error: unknown | undefined,
-    ...args: unknown[]
-  ): void {
+  static logWarn(message: string, error: unknown | undefined, ...args: unknown[]): void {
     console.warn(`WARN: ${message} error=${error}`, args);
   }
 }

package/src/application/models/api/orgConfigResults.ts

@@ -1,7 +1,7 @@
-import { OrganizationStatusEnum } from "@spiffy-ai/commerce-api-client";
-import { OrganizationConfig } from "src/application/models/api/organizationConfig";
-import { ColorMapping } from "src/application/models/colorsConfig";
-import { FrontendConfig } from "src/application/models/frontendConfig";
+import { OrganizationStatusEnum } from '@spiffy-ai/commerce-api-client';
+import { OrganizationConfig } from 'src/application/models/api/organizationConfig';
+import { ColorMapping } from 'src/application/models/colorsConfig';
+import { FrontendConfig } from 'src/application/models/frontendConfig';
 
 export interface OrgConfigExperiment {
   group?: string;

package/src/application/models/cachedValue.ts

@@ -3,6 +3,4 @@ interface CachedValue {
   expiry: number;
 }
 
-export type {
-  CachedValue
-}
+export type { CachedValue };

package/src/application/models/clientDetails.ts

@@ -13,6 +13,4 @@ interface ClientDetails {
   userAgent?: string;
 }
 
-export type {
-  ClientDetails,
-};
+export type { ClientDetails };