@envive-ai/react-hooks 0.2.5 → 0.2.6-alpha

package/dist/src/application/commerce-api.js

@@ -0,0 +1,406 @@
+var _a;
+import { ContextEnvEnum, Configuration, CustomerServiceApi, DefaultApi, InferenceApi, ResponseError, UserEventCategory, ContextSourceEnum, V1OrgConfigGetSourceEnum, ResponseCategory, FormType, } from "@spiffy-ai/commerce-api-client";
+import { ProductExperiment, } from "@envive-ai/types";
+import { userIdAtom, chatIdAtom } from "src/atoms/app";
+import { getAtomStore } from "src/atoms/atomStore";
+import { baseUrlAtom, orgShortNameAtom, contextSourceAtom, envAtom, reactAppNameAtom, } from "src/atoms/envive/enviveConfig";
+import { orgIdAtom, featureFlagServiceAtom } from "src/atoms/org";
+import { UnsupportedProductException, SessionRestartRequired, } from "src/exceptions";
+import Logger from "./logging/logger";
+import { validateResponse, validateSuggestion, validateUserEvent, validateOrgConfigResults, } from "./models";
+import { messageRequestToCommerceMessageRequest, messageFromResponse, messageFromQueryEvent, messageFromSuggestionEvent, messageFromFormSubmittedEvent, coreSupportedEventRequestToApiRequest, } from "./utils";
+async function errorResponseBody(error) {
+    try {
+        return await error.response.json();
+    }
+    catch {
+        return {};
+    }
+}
+async function throwSessionRestartRequiredIf(errorMsg, error) {
+    var _b, _c, _d, _e;
+    if (!(error instanceof ResponseError)) {
+        Logger.logInfo(errorMsg, error);
+        throw error;
+    }
+    const errorResponse = await errorResponseBody(error);
+    if (((_b = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.message) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === "unsupported product" || // for backward compatibility. newer versions of the API return sub_code instead of message
+        ((_c = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.app_code) === null || _c === void 0 ? void 0 : _c.toUpperCase()) === "PRODUCT_NOT_FOUND") {
+        throw new UnsupportedProductException();
+    }
+    else if (((_d = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.app_code) === null || _d === void 0 ? void 0 : _d.toUpperCase()) === "RESTART_SESSION" ||
+        ((_e = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.sub_code) === null || _e === void 0 ? void 0 : _e.toUpperCase()) === "NOT_FOUND" // for backward compatibility. new API responses will contain "app_code"
+    ) {
+        Logger.logInfo("Session does not exist. Re-start session", error, error.response, errorResponse);
+        throw new SessionRestartRequired();
+    }
+    Logger.logInfo(errorMsg, error);
+    throw error;
+}
+class CommerceApiClient {
+    constructor(basePath) {
+        this.suggestionsAbortController = new AbortController();
+        this.responsesAbortController = new AbortController();
+        const atomStore = getAtomStore();
+        const baseUrl = atomStore.get(baseUrlAtom);
+        const path = basePath || baseUrl;
+        // API Key is now handled at the EnviveConfigProvider level
+        const config = new Configuration({
+            basePath: path,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+        });
+        this.defaultApi = new DefaultApi(config);
+        this.inferenceApi = new InferenceApi(config);
+        this.customerServiceApi = new CustomerServiceApi(config);
+    }
+}
+_a = CommerceApiClient;
+CommerceApiClient.getInstance = () => {
+    if (!_a.instance) {
+        _a.instance = new _a();
+    }
+    return _a.instance;
+};
+CommerceApiClient.resolveUrl = async (url) => {
+    var _b, _c;
+    const atomStore = getAtomStore();
+    const orgShortName = atomStore.get(orgShortNameAtom);
+    const orgId = atomStore.get(orgIdAtom);
+    const userId = atomStore.get(userIdAtom);
+    const chatId = atomStore.get(chatIdAtom);
+    const source = atomStore.get(contextSourceAtom);
+    const env = atomStore.get(envAtom);
+    const featureFlagService = atomStore.get(featureFlagServiceAtom);
+    const context = {
+        user_id: userId !== null && userId !== void 0 ? userId : "",
+        org_id: orgId !== null && orgId !== void 0 ? orgId : "",
+        org_short_name: orgShortName !== null && orgShortName !== void 0 ? orgShortName : "",
+        chat_id: chatId !== null && chatId !== void 0 ? chatId : "",
+        source: source !== null && source !== void 0 ? source : ContextSourceEnum.App,
+        env: (_b = env) !== null && _b !== void 0 ? _b : ContextEnvEnum.Dev, // Cast env to ContextEnvEnum
+    };
+    const featureGates = ((_c = featureFlagService === null || featureFlagService === void 0 ? void 0 : featureFlagService.featureFlagService) === null || _c === void 0 ? void 0 : _c.getFeatureFlags()) || {};
+    const urlResolvingRequest = {
+        url,
+        context,
+        feature_gates: featureGates,
+    };
+    const rawResponse = await _a.getInstance().inferenceApi.v1UrlResolvingPostRaw({
+        UrlResolvingRequest: urlResolvingRequest,
+    });
+    const responseBody = await rawResponse.raw.json();
+    return responseBody;
+};
+CommerceApiClient.reportSession = async (reportRequest) => {
+    await _a.getInstance().defaultApi.v1ChatsReportSessionIdPost({
+        ReportSessionRequest: reportRequest,
+    });
+};
+CommerceApiClient.getNextResponses = async (payload) => {
+    try {
+        const response = await _a.getInstance().inferenceApi.v1NextResponsesPost({
+            NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
+        });
+        const messages = response
+            .map((resp) => validateResponse(resp))
+            .map((resp) => messageFromResponse(resp));
+        return messages.filter((m) => m != null);
+    }
+    catch (err) {
+        Logger.logInfo("Failed to get next responses", err, {
+            payloadContext: payload === null || payload === void 0 ? void 0 : payload.context,
+            userEvents: payload === null || payload === void 0 ? void 0 : payload.userEvents,
+        });
+        await throwSessionRestartRequiredIf("Failed to get next responses", err);
+        return [];
+    }
+};
+CommerceApiClient.getNextResponseStreaming = (payload) => {
+    async function* generate(inferenceApi, abortController) {
+        // make sure streaming is enabled
+        try {
+            const response = await inferenceApi.v1NextResponsesPostRaw({
+                NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
+            }, { 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,
+                });
+                return;
+            }
+            const reader = response.raw.body.getReader();
+            const decoder = new TextDecoder("utf-8");
+            let partial = "";
+            // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
+            const safeParse = (line) => {
+                try {
+                    return JSON.parse(line); // Parse the JSON string
+                }
+                catch (err) {
+                    Logger.logError("[spiffy-ai] Error parsing streamed line", err, {
+                        line,
+                        partial,
+                    });
+                    // swallow the error and set the partial to our current chunk
+                    partial = line;
+                    return partial;
+                }
+            };
+            // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
+            const processChunk = (chunk) => {
+                // merge the partial with the incoming chunk
+                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(safeParse)
+                    .filter((v) => v); // and filter out the undefined values
+                return parsedLines;
+            };
+            while (true) {
+                // eslint-disable-next-line no-await-in-loop
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                // Massage and parse the chunk of data
+                const chunk = decoder.decode(value);
+                const parsedLines = processChunk(chunk);
+                for (const parsedLine of parsedLines) {
+                    const validatedResponse = validateResponse(parsedLine);
+                    if (validatedResponse) {
+                        yield validatedResponse;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.logError("[spiffy-ai] Failed to get next streaming responses", error, {
+                payloadContext: payload === null || payload === void 0 ? void 0 : payload.context,
+                userEvents: payload === null || payload === void 0 ? void 0 : payload.userEvents,
+            });
+            await throwSessionRestartRequiredIf("Failed to get next streaming responses", error);
+        }
+    }
+    _a.getInstance().responsesAbortController.abort();
+    _a.getInstance().responsesAbortController =
+        new AbortController();
+    return generate(_a.getInstance().inferenceApi, _a.getInstance().responsesAbortController);
+};
+CommerceApiClient.getNextSuggestions = async (payload) => {
+    try {
+        _a.getInstance().suggestionsAbortController.abort();
+        _a.getInstance().suggestionsAbortController =
+            new AbortController();
+        const response = await _a.getInstance().inferenceApi.v1NextSuggestionsPost({
+            NextMessageRequest: messageRequestToCommerceMessageRequest(payload),
+        }, {
+            signal: _a.getInstance().suggestionsAbortController.signal,
+        });
+        const suggestions = response
+            .map((resp) => validateSuggestion(resp))
+            .filter((suggestion) => suggestion != null);
+        return suggestions;
+    }
+    catch (error) {
+        Logger.logInfo("Failed to get suggestions", error, {
+            payloadContext: payload === null || payload === void 0 ? void 0 : payload.context,
+            userEvents: payload === null || payload === void 0 ? void 0 : payload.userEvents,
+        });
+        await throwSessionRestartRequiredIf("Failed to get suggestions", error);
+        return [];
+    }
+};
+/**
+ * Fetches the existing chat data for a given session and transforms them to reconstruct the chat history.
+ *
+ * @param orgId The organization Id
+ * @param chatId The existing chat Id
+ * @param userId The user Id
+ *
+ * @returns A list of messages that were exchanged in the chat, throws an error if the chat session has expired.
+ */
+CommerceApiClient.getResponses = async (orgId, chatId, userId) => {
+    var _b;
+    let data = {
+        responses: [],
+        suggestions: [],
+        user_events: [],
+    };
+    const request = {
+        org_id: orgId,
+        chat_id: chatId,
+        user_id: userId,
+    };
+    try {
+        data =
+            await _a.getInstance().defaultApi.v1GetSessionMessages(request);
+    }
+    catch (error) {
+        await throwSessionRestartRequiredIf("Failed to get chat responses", error);
+    }
+    const responses = (_b = data === null || data === void 0 ? void 0 : data.responses) === null || _b === void 0 ? void 0 : _b.map((turn) => turn
+        .map((response) => validateResponse(response))
+        .filter((response) => response != null));
+    const suggestions = data === null || data === void 0 ? void 0 : data.suggestions.map((suggestion) => validateSuggestion(suggestion)).filter((suggestion) => suggestion != null);
+    const userEvents = data === null || data === void 0 ? void 0 : data.user_events.map((event) => validateUserEvent(event)).filter((event) => 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);
+    const assistantMessages = responses
+        .map((turn) => turn
+        .filter((response) => !(response.category === ResponseCategory.Form &&
+        formSubmittedUserEventsFormIds.includes(response.id)))
+        .map((response) => messageFromResponse(response))
+        .filter((message) => message != null))
+        .filter((turn) => turn.length > 0);
+    const userMessages = userEvents
+        .map((event) => {
+        if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) {
+            return [messageFromQueryEvent(event)];
+        }
+        if (event.category === UserEventCategory.SuggestionClicked) {
+            return [messageFromSuggestionEvent(event, suggestions)];
+        }
+        if (event.category === UserEventCategory.FormSubmitted) {
+            const formResponse = responses
+                .flat()
+                .find((response) => response.id === event.attributes.formResponseId &&
+                event.attributes.formType !== FormType.Escalation);
+            if (formResponse && formResponse.category === ResponseCategory.Form) {
+                return [
+                    messageFromFormSubmittedEvent(event, formResponse.attributes),
+                ];
+            }
+        }
+        return [];
+    })
+        .filter((message) => message.length > 0);
+    // 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());
+    return { responses, userEvents, suggestions, messages: sortedMessages };
+};
+/**
+ *
+ * @param payload
+ * @returns
+ */
+CommerceApiClient.isSupportedEvent = async (payload) => {
+    try {
+        const rawResponse = await _a.getInstance().inferenceApi.v1SupportedEventPostRaw({
+            SupportedEventRequest: coreSupportedEventRequestToApiRequest(payload),
+        });
+        // Get the actual HTTP response JSON
+        const httpResponseText = await rawResponse.raw.text();
+        const httpResponseJson = JSON.parse(httpResponseText);
+        return {
+            ...httpResponseJson,
+            numberOfReviews: httpResponseJson.num_of_reviews,
+            merchant_tags: httpResponseJson.merchant_tags || [],
+        };
+    }
+    catch (err) {
+        Logger.logError("Failed to get response for v1SupportedEventPost", {
+            err,
+        });
+        return {
+            supported: false,
+            ready: false,
+            category: undefined,
+            collections: [],
+            numberOfReviews: undefined,
+            top_category: undefined,
+            merchant_tags: [],
+        };
+    }
+};
+CommerceApiClient.identifyUser = async (spiffyUserId, merchantUserId, uaDetails) => {
+    try {
+        await _a.getInstance().defaultApi.v1AnalyticsIdentifyPost({
+            AnalyticsIdentifyRequest: {
+                user_id: spiffyUserId,
+                os_name: uaDetails.os,
+                os_version: uaDetails.osVersion,
+                platform: uaDetails.os,
+                device_id: uaDetails.deviceModel,
+                device_brand: uaDetails.deviceBrand,
+                device_manufacturer: uaDetails.deviceManufacturer,
+                device_model: uaDetails.deviceModel,
+                user_properties: {
+                    cdp_user_id: merchantUserId,
+                    browser: uaDetails.browser,
+                    browser_version: uaDetails.browserVersion,
+                    user_agent: uaDetails.userAgent,
+                },
+            },
+        });
+    }
+    catch (err) {
+        Logger.logError("Failed to identify user", err);
+    }
+};
+CommerceApiClient.mapContextSourceToV1OrgConfigGetSource = (source) => {
+    if (source === undefined)
+        return undefined;
+    switch (source) {
+        case ContextSourceEnum.Fork:
+            return V1OrgConfigGetSourceEnum.Fork;
+        case ContextSourceEnum.Playground:
+            return V1OrgConfigGetSourceEnum.Playground;
+        case ContextSourceEnum.App:
+            return V1OrgConfigGetSourceEnum.App;
+        case ContextSourceEnum.Test:
+            return V1OrgConfigGetSourceEnum.Test;
+        default: {
+            // This ensures that if new values are added to ContextSourceEnum, we catch it
+            const exhaustiveCheck = source;
+            return exhaustiveCheck;
+        }
+    }
+};
+CommerceApiClient.getOrgConfig = async (user_id) => {
+    var _b;
+    try {
+        const atomStore = getAtomStore();
+        const reactAppName = atomStore.get(reactAppNameAtom);
+        const contextSource = atomStore.get(contextSourceAtom);
+        const featureFlagService = atomStore.get(featureFlagServiceAtom); // Get featureFlagService
+        const request = {
+            namespace: reactAppName,
+            user_id,
+            source: _a.mapContextSourceToV1OrgConfigGetSource(contextSource),
+            include_experiments: Object.values(ProductExperiment),
+            include_feature_gates: Object.entries(((_b = featureFlagService === null || featureFlagService === void 0 ? void 0 : featureFlagService.featureFlagService) === null || _b === void 0 ? void 0 : _b.getFeatureFlags()) || {})
+                .filter(([, isEnabled]) => isEnabled)
+                .map(([featureGateName]) => featureGateName), // Use featureFlagService
+        };
+        const response = await _a.getInstance().defaultApi.v1OrgConfigGet(request);
+        return validateOrgConfigResults(response);
+    }
+    catch (err) {
+        Logger.logError(`Failed to get org config`, err, { err });
+        return undefined;
+    }
+};
+CommerceApiClient.addNoteToLatestConversation = async (spiffyUserId, email, customerServiceProvider) => {
+    Logger.logInfo(`addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`);
+    try {
+        await _a.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost({
+            AddNoteToLatestConversationRequest: {
+                spiffy_user_id: spiffyUserId,
+                email,
+                customer_service_provider: customerServiceProvider,
+            },
+        });
+    }
+    catch (err) {
+        Logger.logError("Failed to add note to latest conversation", { err });
+    }
+};
+CommerceApiClient.getCustomerServiceApi = () => _a.getInstance().customerServiceApi;
+export default CommerceApiClient;

package/dist/src/application/logging/logger.js

@@ -0,0 +1,16 @@
+/* eslint-disable no-console */
+class Logger {
+    static logInfo(message, ...args) {
+        console.info(`INFO: ${message}`, ...args);
+    }
+    static logDebug(message, ...args) {
+        console.debug(`DEBUG: ${message}`, ...args);
+    }
+    static logError(message, error, ...args) {
+        console.error(`ERROR: ${message} error=${error}`, args);
+    }
+    static logWarn(message, error, ...args) {
+        console.warn(`WARN: ${message} error=${error}`, args);
+    }
+}
+export default Logger;

package/dist/src/application/models/graphql/index.js

@@ -0,0 +1,3 @@
+export * from './queries/getMerchantFrontendConfigQuery';
+export * from './queries/getMerchantColorsQuery';
+export * from './queries/getMerchantOrgIdQuery';

package/dist/src/application/models/graphql/queries/getMerchantColorsQuery.js

@@ -0,0 +1,13 @@
+import { configVersion } from '../../../../util/configVersion';
+const getMerchantColorsQuery = () => `
+  query ($version: "${configVersion()}") {
+    me {
+      getProductsConfigByVersion(version: $version) {
+        colors {
+          values
+        }
+      }
+    }
+  }
+`;
+export { getMerchantColorsQuery };

package/dist/src/application/models/graphql/queries/getMerchantFrontendConfigQuery.js

@@ -0,0 +1,13 @@
+import { configVersion } from '../../../../util/configVersion';
+const getMerchantFrontendConfigQuery = () => `
+  query ($version: "${configVersion()}") {
+    me {
+      getProductsConfigByVersion(version: $version) {
+        frontend {
+          values
+        }
+      }
+    }
+  }
+`;
+export { getMerchantFrontendConfigQuery };

package/dist/src/application/models/graphql/queries/getMerchantOrgIdQuery.js

@@ -0,0 +1,10 @@
+const getMerchantOrgIdQuery = `
+  query {
+    me {
+      org {
+        id
+      }
+    }
+  }
+`;
+export { getMerchantOrgIdQuery };

package/dist/src/application/models/guards/api/index.js

@@ -0,0 +1,12 @@
+export * from './isApiPDPEventAttributes';
+export * from './isApiQueryTypedEventAttributes';
+export * from './isApiResponse';
+export * from './isApiProductResponseAttributes';
+export * from './isApiReviewResponseAttributes';
+export * from './isApiReviewRichInformation';
+export * from './isApiSearchEventAttributes';
+export * from './isApiSuggestion';
+export * from './isApiSuggestionClickedEventAttributes';
+export * from './isApiTextResponseAttributes';
+export * from './isApiUserEvent';
+export * from './isApiProductSearchAttributes';

package/dist/src/application/models/guards/api/isApiFormResponse.js

@@ -0,0 +1,59 @@
+import { FormType } from '@spiffy-ai/commerce-api-client';
+import Logger from 'src/application/logging/logger';
+import { hasPropertyOfType } from '../utils';
+/**
+ * Type guard to check if the provided data has the all of the properties (with the correct types) of
+ * a FormResponseAttribute
+ *
+ * @param data - The data to check
+ *
+ * @returns true if the data has the correct properties, false otherwise
+ */
+export const isApiFormResponseAttributes = (data) => {
+    if (data == null || typeof data !== 'object') {
+        Logger.logError('isApiFormResponseAttributes: data is null or not an object', undefined, {
+            data,
+        });
+        return false;
+    }
+    if ('form_category' in data && typeof data.form_category !== 'object') {
+        Logger.logError('isApiFormResponseAttributes: form_category is not an object', undefined, {
+            data,
+        });
+        return false;
+    }
+    if ('form_category' in data && typeof data.form_category === 'object') {
+        if (!hasPropertyOfType(data.form_category, 'form_type', 'string') ||
+            !Object.values(FormType).includes(data.form_category.form_type)) {
+            Logger.logError('isApiFormResponseAttributes: form_type is missing or not a valid form type', undefined, {
+                data,
+            });
+            return false;
+        }
+    }
+    if (!hasPropertyOfType(data, 'schema', 'object')) {
+        Logger.logError('isApiFormResponseAttributes: schema is missing or not an object', undefined, {
+            data,
+        });
+        return false;
+    }
+    // TODO: also wanna validate the fields of data.schema.properties but might wanna change the schema
+    // to not have the property name as a key in the object
+    if (!hasPropertyOfType(data.schema, 'properties', 'object')) {
+        Logger.logError('isApiFormResponseAttributes: schema.properties is missing or not an object', undefined, {
+            data,
+        });
+        return false;
+    }
+    if (!hasPropertyOfType(data.schema, 'required', 'array')) {
+        Logger.logError('isApiFormResponseAttributes: schema.required is missing or not an array', undefined, { data });
+        return false;
+    }
+    if (!data.schema.required.every((key) => typeof key === 'string' && key in data.schema.properties)) {
+        Logger.logError('isApiFormResponseAttributes: schema.required contains invalid property keys', undefined, {
+            data,
+        });
+        return false;
+    }
+    return true;
+};

package/dist/src/application/models/guards/api/isApiFormSubmittedResponseAttributes.js

@@ -0,0 +1,22 @@
+import { FormType } from '@spiffy-ai/commerce-api-client';
+import Logger from 'src/application/logging/logger';
+import { hasPropertyOfType } from '../utils';
+export const isApiFormSubmittedResponseAttributes = (data) => {
+    if (data == null || typeof data !== 'object') {
+        Logger.logError('isApiFormSubmittedResponseAttributes', 'data is null or not an object', data);
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'filled_schema', 'object')) {
+        Logger.logError('isApiFormSubmittedResponseAttributes', 'filled_schema is not an object', data);
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'form_response_id', 'string')) {
+        Logger.logError('isApiFormSubmittedResponseAttributes', 'form_response_id is not a string', data);
+        return false;
+    }
+    if (!('form_type' in data) || !Object.values(FormType).includes(data.form_type)) {
+        Logger.logError('isApiFormSubmittedResponseAttributes', 'form_type is not a valid form type enum', data);
+        return false;
+    }
+    return true;
+};

package/dist/src/application/models/guards/api/isApiOrderResponseAttributes.js

@@ -0,0 +1,91 @@
+import Logger from 'src/application/logging/logger';
+import { hasPropertyOfType } from '../utils';
+const isApiOrderItemInfo = (data) => {
+    if (data == null || typeof data !== 'object') {
+        Logger.logError('OrderItemInfo must be an object', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'order_item_id', 'string')) {
+        Logger.logError('OrderItemInfo must have an order_item_id property', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'item_title', 'string')) {
+        Logger.logError('OrderItemInfo must have an item_title property', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'item_price', 'number')) {
+        Logger.logError('OrderItemInfo must have an item_price property', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'item_quantity', 'number')) {
+        Logger.logError('OrderItemInfo must have an item_quantity property', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'image', 'string', true)) {
+        Logger.logError('OrderItemInfo.image must be a string or null', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'fulfillment_display_status', 'string', true)) {
+        Logger.logError('OrderItemInfo.fulfillment_display_status must be a string or null', undefined, {
+            data,
+        });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'tracking_url', 'string', true)) {
+        Logger.logError('OrderItemInfo.tracking_url must be a string or null', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'delivered_at', 'string', true)) {
+        Logger.logError('OrderItemInfo.delivered_at must be a string or null', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'estimated_delivery_at', 'string', true)) {
+        Logger.logError('OrderItemInfo.estimated_delivery_at must be a string or null', undefined, {
+            data,
+        });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'in_transit_at', 'string', true)) {
+        Logger.logError('OrderItemInfo.in_transit_at must be a string or null', undefined, { data });
+        return false;
+    }
+    return true;
+};
+export const isApiOrderResponseAttributes = (data) => {
+    if (data == null || typeof data !== 'object') {
+        Logger.logError('Order response attributes must be an object', undefined, { data });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'created_at', 'string')) {
+        Logger.logError('Order response attributes must have a created_at property and have type string', undefined, {
+            data,
+        });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'latest_event_date', 'string')) {
+        Logger.logError('Order response attributes must have a latest_event_date property and have type string', undefined, {
+            data,
+        });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'line_items', 'array') ||
+        !data.line_items.every((item) => isApiOrderItemInfo(item))) {
+        Logger.logError('Order response attributes must have a line_items property with at least one order item', undefined, {
+            data,
+        });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'order_id', 'string')) {
+        Logger.logError('Order response attributes must have an order_id property and have type string', undefined, {
+            data,
+        });
+        return false;
+    }
+    if (!hasPropertyOfType(data, 'order_number', 'string')) {
+        Logger.logError('Order response attributes must have an order_number property and have type string', undefined, {
+            data,
+        });
+        return false;
+    }
+    return true;
+};