flowrix 1.0.1-beta.14 → 1.0.1-beta.141

package/dist/runtime/server/api/service/[slug].js

@@ -1,8 +1,9 @@
-import { defineEventHandler, getRouterParam, getQuery, createError, readBody } from "h3";
-import { $fetch } from "ofetch";
+import { defineEventHandler, getRouterParam, getQuery, createError, readBody, getCookie, setResponseStatus } from "h3";
 import { writeFile, mkdir, readFile } from "fs/promises";
 import { join } from "path";
-const CACHE_DIR = join(process.cwd(), ".nuxt", "cache", "nitro", "services");
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "services");
 export const serviceCache = /* @__PURE__ */ new Map();
 async function ensureCacheDir() {
   try {
@@ -13,6 +14,7 @@ async function ensureCacheDir() {
 }
 export default defineEventHandler(async (event) => {
   const slug = getRouterParam(event, "slug");
+  const customerType = getCookie(event, "customertype") || "";
   const query = getQuery(event);
   const body = await readBody(event);
   if (!slug) {
@@ -23,7 +25,7 @@ export default defineEventHandler(async (event) => {
   }
   const cacheKey = `${slug}-${JSON.stringify(query)}`;
   const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
-  const filePath = join(CACHE_DIR, `${fileName}.json`);
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
   try {
     const fileContent = await readFile(filePath, "utf-8");
     const service = JSON.parse(fileContent);
@@ -31,21 +33,25 @@ export default defineEventHandler(async (event) => {
   } catch (error) {
   }
   try {
-    const service = await $fetch(`${process.env.FLOWRIX_API_BASE}services/${slug}`, {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const options = {
       headers: {
-        "x-api-key": process.env.FLOWRIX_API_KEY,
-        "x-api-secret": process.env.FLOWRIX_API_SECRET,
-        "Origin": process.env.FLOWRIX_API_ORIGIN
+        "x-api-secret": apiConfig?.FLOWRIX_API_SECRET || ""
       }
-    });
-    await ensureCacheDir();
-    await writeFile(filePath, JSON.stringify(service, null, 2), "utf-8");
+    };
+    const service = await flowrixApi.get(`services/${slug}`, apiConfig, options);
+    if (config.FLOWRIX_CACHE == "true" || config.public.FLOWRIX_CACHE == "true") {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(service, null, 2), "utf-8");
+    }
     return service;
   } catch (error) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: `Failed to fetch service for slug: ${slug}`,
-      data: error.message
-    });
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
   }
 });

package/dist/runtime/server/api/service/availability.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
 export default _default;

package/dist/runtime/server/api/service/availability.js

@@ -1,25 +1,27 @@
+import { useRuntimeConfig } from "#imports";
 import { defineEventHandler, readBody } from "h3";
+import { flowrixApi } from "../../../middleware/flowrix.js";
 export default defineEventHandler(async (event) => {
   const body = await readBody(event);
   try {
-    const response = await fetch(`${process.env.FLOWRIX_API_BASE}services/availability`, {
-      method: "POST",
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const options = {
       headers: {
-        "x-api-key": process.env.FLOWRIX_API_KEY || "",
-        "x-api-secret": process.env.FLOWRIX_API_SECRET || "",
-        "Origin": process.env.FLOWRIX_API_ORIGIN || "",
-        "Content-Type": "application/json",
-        "Accept": "application/json"
+        "x-api-secret": apiConfig?.FLOWRIX_API_SECRET || ""
       },
       body: JSON.stringify(body)
-    });
-    const responseData = await response.json();
-    return responseData;
+    };
+    const response = await flowrixApi.post(`services/availability`, apiConfig, options);
+    return response;
   } catch (error) {
-    console.error("Error in service availability:", error);
     return {
       status: "Error",
-      statusCode: 500,
+      statusCode: 422,
       message: "Internal server error",
       error: error.message || "Unknown error"
     };

package/dist/runtime/server/api/service/getall.d.ts

@@ -0,0 +1,3 @@
+export declare const serviceCache: Map<any, any>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/service/getall.js

@@ -0,0 +1,57 @@
+import { defineEventHandler, getQuery, createError, readBody, getCookie, setResponseStatus } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "services");
+export const serviceCache = /* @__PURE__ */ new Map();
+async function ensureCacheDir() {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+  } catch (error) {
+    console.error("Error creating cache directory:", error);
+  }
+}
+export default defineEventHandler(async (event) => {
+  const slug = "all";
+  const customerType = getCookie(event, "customertype") || "";
+  let query = getQuery(event);
+  const body = await readBody(event);
+  if (!slug) {
+    throw createError({ statusCode: 400, statusMessage: "Missing slug parameter" });
+  }
+  if (!/^[a-zA-Z0-9-_]+$/.test(slug)) {
+    throw createError({ statusCode: 400, statusMessage: "Invalid slug" });
+  }
+  const cacheKey = `${slug}-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const service = JSON.parse(fileContent);
+    return service;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const options = {
+      headers: {
+        "x-api-secret": apiConfig?.FLOWRIX_API_SECRET || ""
+      }
+    };
+    const service = await flowrixApi.get(`services`, apiConfig, options);
+    if (config.FLOWRIX_CACHE == "true" || config.public.FLOWRIX_CACHE == "true") {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(service, null, 2), "utf-8");
+    }
+    return service;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/server/api/shop.d.ts

@@ -0,0 +1,3 @@
+export declare const catelogCache: Map<any, any>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/shop.js

@@ -0,0 +1,53 @@
+import { defineEventHandler, getQuery, getCookie, setResponseStatus } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "catalog");
+export const catelogCache = /* @__PURE__ */ new Map();
+async function ensureCacheDir() {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+  } catch (error) {
+    console.error("Error creating cache directory:", error);
+  }
+}
+export default defineEventHandler(async (event) => {
+  let query = getQuery(event);
+  const customerType = getCookie(event, "customertype") || "";
+  const cacheKey = `search-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const catelog = JSON.parse(fileContent);
+    return catelog;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    query = {
+      ...query
+    };
+    const options = {
+      headers: {
+        "x-api-secret": apiConfig?.FLOWRIX_API_SECRET || ""
+      },
+      query
+    };
+    const search = await flowrixApi.get(`search`, apiConfig, options);
+    if (config.FLOWRIX_CACHE == "true" || config.public.FLOWRIX_CACHE == "true") {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(search, null, 2), "utf-8");
+    }
+    return search;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/server/api/subscribe.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
 export default _default;

package/dist/runtime/server/api/subscribe.js

@@ -1,16 +1,25 @@
-import { defineEventHandler, readBody } from "h3";
-import { $fetch } from "ofetch";
+import { defineEventHandler, readBody, setResponseStatus } from "h3";
+import { flowrixApi } from "../../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 export default defineEventHandler(async (event) => {
-  const body = await readBody(event);
-  const subscribe = await $fetch(`${process.env.FLOWRIX_API_BASE}subscribe`, {
-    method: "POST",
-    headers: {
-      "x-api-key": process.env.FLOWRIX_API_KEY,
-      "x-api-secret": process.env.FLOWRIX_API_SECRET,
-      "Origin": process.env.FLOWRIX_API_ORIGIN,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-  return subscribe;
+  try {
+    const body = await readBody(event);
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const options = {
+      headers: {
+        "x-api-secret": apiConfig?.FLOWRIX_API_SECRET || ""
+      },
+      body: JSON.stringify(body)
+    };
+    const subscribe = await flowrixApi.post(`subscribe`, apiConfig, options);
+    return subscribe;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
 });

package/dist/runtime/server/api/v2/[...slug].get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
+export default _default;

package/dist/runtime/server/api/v2/[...slug].get.js

@@ -0,0 +1,32 @@
+import { defineEventHandler } from "h3";
+import { flowrixApi } from "../../../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+import { existsSync } from "fs";
+import { join } from "path";
+import { rm } from "fs/promises";
+export default defineEventHandler(async (event) => {
+  const slug = event.context.params._;
+  const config = useRuntimeConfig();
+  const rawCookies = event.req.headers.cookie || "";
+  const apiConfig = {
+    ...config,
+    cookies: rawCookies
+  };
+  const options = {
+    headers: {
+      "x-api-secret": apiConfig?.FLOWRIX_API_SECRET || ""
+    }
+  };
+  const page = await flowrixApi.get(`permalink/${slug}`, apiConfig, options);
+  if (config.FLOWRIX_CACHE != "true" || config.public?.FLOWRIX_CACHE != "true") {
+    const CACHE_DIR = join("/tmp", ".cache");
+    if (existsSync(CACHE_DIR)) {
+      await rm(CACHE_DIR, { recursive: true, force: true });
+    } else {
+      console.log("\u2139\uFE0F Flowrix: No .cache folder found \u2014 skipping cleanup.");
+    }
+  }
+  if (page.status === "Success" && page.data.type === "Redirect") {
+  }
+  return page;
+});

package/dist/runtime/server/api/webform.d.ts

@@ -0,0 +1,3 @@
+export declare const webfromCache: Map<any, any>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/webform.js

@@ -0,0 +1,54 @@
+import { defineEventHandler, getRouterParam, getQuery, createError, readBody, getCookie, setResponseStatus } from "h3";
+import { writeFile, mkdir, readFile } from "fs/promises";
+import { join } from "path";
+import { useRuntimeConfig } from "#imports";
+import { flowrixApi } from "../../middleware/flowrix.js";
+const CACHE_DIR = join("/tmp", ".cache", "nitro", "webfroms");
+export const webfromCache = /* @__PURE__ */ new Map();
+async function ensureCacheDir() {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+  } catch (error) {
+    console.error("Error creating cache directory:", error);
+  }
+}
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "id");
+  const customerType = getCookie(event, "customertype") || "";
+  let query = getQuery(event);
+  const body = await readBody(event);
+  if (!slug) {
+    throw createError({ statusCode: 400, statusMessage: "Missing slug parameter" });
+  }
+  const cacheKey = `${slug}-${JSON.stringify(query)}`;
+  const fileName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const filePath = join(CACHE_DIR, `${fileName}-${customerType}.json`);
+  try {
+    const fileContent = await readFile(filePath, "utf-8");
+    const webfrom = JSON.parse(fileContent);
+    return webfrom;
+  } catch (error) {
+  }
+  try {
+    const config = useRuntimeConfig();
+    const rawCookies = event.req.headers.cookie || "";
+    const apiConfig = {
+      ...config,
+      cookies: rawCookies
+    };
+    const options = {
+      headers: {
+        "x-api-secret": apiConfig?.FLOWRIX_API_SECRET || ""
+      }
+    };
+    const webfrom = await flowrixApi.get(`contact-center/webforms/${slug}/details`, apiConfig, options);
+    if (config.FLOWRIX_CACHE == "true" || config.public.FLOWRIX_CACHE == "true") {
+      await ensureCacheDir();
+      await writeFile(filePath, JSON.stringify(webfrom, null, 2), "utf-8");
+    }
+    return webfrom;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,3 @@
-{
-  "extends": "../../../.nuxt/tsconfig.server.json",
-}
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/stores/Cart.d.ts

@@ -36,6 +36,17 @@ export interface CartData {
     shippingmethod?: string | number;
     vouchercodes?: string[];
 }
+export interface RelatedData {
+    cart: Record<string, CartItem> | undefined;
+    qty?: number;
+    abndToken?: string;
+    deliverymethod?: number | string;
+    shipping_state?: string | number;
+    shipping_postcode?: number;
+    shipping_country?: string | number;
+    shippingmethod?: string | number;
+    vouchercodes?: string[];
+}
 export interface FormData {
     cart: Record<string, CartItem> | undefined;
     qty: number;
@@ -63,5 +74,6 @@ export interface CartState {
     responseData: [];
     errorResponseData: Record<string, any>;
     addedResponse: string;
+    relatedProducts: any[];
 }
 export declare const useCartStore: import("pinia").StoreDefinition<"cart", CartState, {}, {}>;

package/dist/runtime/stores/Cart.js

@@ -1,7 +1,10 @@
 import { defineStore } from "pinia";
 import { flowrixApi } from "../middleware/flowrix.js";
 import { useCheckoutStore } from "./Checkout.js";
-import { useApi } from "../utils/api.js";
+import { useRuntimeConfig } from "#imports";
+import { GTM_add_to_cart, GTM_remove_from_cart } from "../composables/useDataLayer.js";
+import { META_add_to_cart, META_remove_from_cart } from "../composables/useMetaLayer.js";
+import { TikTok_add_to_cart, TikTok_remove_from_cart } from "../composables/useTikTokDatalayer.js";
 export const useCartStore = defineStore("cart", {
   state: () => ({
     cart: {},
@@ -64,8 +67,14 @@ export const useCartStore = defineStore("cart", {
         apiUrl = `cart/service/${service.slug}/add`;
       }
       try {
-        console.log(apiUrl);
-        const response = await flowrixApi.post(apiUrl, { body: formData });
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(
+          apiUrl,
+          config,
+          {
+            body: formData
+          }
+        );
         if (response?.status == "Success") {
           this.addedResponse = "success";
           this.cart = {
@@ -73,7 +82,10 @@ export const useCartStore = defineStore("cart", {
             ["totals"]: response?.data.calculations,
             ["abndToken"]: response?.data.abndToken
           };
-          this.lastitem = response?.data.lastItem;
+          this.lastitem = response?.data.lastitem;
+          GTM_add_to_cart(response?.data.lastitem);
+          META_add_to_cart(response?.data.lastitem);
+          TikTok_add_to_cart(response?.data.lastitem);
           useCheckoutStore().saveToCheckoutSession({
             cart: response?.data,
             calculations: response?.data.calculations,
@@ -88,9 +100,23 @@ export const useCartStore = defineStore("cart", {
         this.addedResponse = "";
       }
     },
+    async fetchRelated() {
+      try {
+        const request = {
+          cart: this.cart.items
+        };
+        const apiUrl = `/api/cart/related`;
+        const response = await $fetch(apiUrl, {
+          method: "POST",
+          body: request
+        });
+        return response;
+      } catch (error) {
+        console.error("Error removing from cart:", error);
+      }
+    },
     async removeFromCart(id, product) {
       try {
-        const { post } = useApi();
         const checkoutSession = useCheckoutStore().checkoutSession;
         const apiUrl = `cart/remove`;
         const request = {
@@ -106,14 +132,18 @@ export const useCartStore = defineStore("cart", {
         if (this.coupon?.length > 0) {
           request.vouchercodes = this.coupon;
         }
-        const response = await post(apiUrl, request);
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, {
+          body: request
+        });
         if (response?.status == "Success") {
           this.cart = {
             ["items"]: response?.data.cart,
             ["totals"]: response?.data.calculations,
             ["abndToken"]: response?.data.abndToken
           };
-          this.lastitem = response?.data.lastItem;
+          this.lastitem = response?.data.lastitem;
+          GTM_remove_from_cart(response?.data.lastitem);
           useCheckoutStore().saveToCheckoutSession({
             cart: response.cart.items,
             calculations: response.cart.calculations,
@@ -130,36 +160,37 @@ export const useCartStore = defineStore("cart", {
     async updateQuantity(product, qty) {
       try {
         const checkoutSession = useCheckoutStore().checkoutSession;
-        const { post } = useApi();
         const apiUrl = `cart/${product.slug}/update`;
         const request = {
           cart: this.cart.items,
           rowId: product.rowId,
           qty,
           deliverymethod: checkoutSession?.fields?.deliverymethod,
-          // shipping_state: checkoutSession?.fields?.shipping_state,
-          // shipping_postcode: checkoutSession?.fields?.shipping_postcode,
-          // shipping_country: checkoutSession?.fields?.shipping_country,
           shippingmethod: checkoutSession?.fields?.shippingmethod,
           abndToken: this.cart.abndToken
         };
         if (this.coupon?.length > 0) {
           request.vouchercodes = this.coupon;
         }
-        const response = await post(apiUrl, request);
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, {
+          body: request
+        });
         if (response?.status == "Success") {
           this.cart = {
             ["items"]: response?.data.cart,
             ["totals"]: response?.data.calculations,
             ["abndToken"]: response?.data.abndToken
           };
-          this.lastitem = response?.data.lastItem;
+          this.lastitem = response?.data.lastitem;
           if (qty < product.qty) {
             GTM_remove_from_cart(this.lastitem);
             META_remove_from_cart(this.lastitem);
+            TikTok_remove_from_cart(this.lastitem);
           } else {
             GTM_add_to_cart(this.lastitem);
             META_add_to_cart(this.lastitem);
+            TikTok_add_to_cart(this.lastitem);
           }
           useCheckoutStore().saveToCheckoutSession({
             cart: response.data.cart,
@@ -178,12 +209,11 @@ export const useCartStore = defineStore("cart", {
       try {
         let couponsCodes = this.coupon || [];
         const checkoutSession = useCheckoutStore().checkoutSession;
-        const { post } = useApi();
-        let apiUrl = "/checkout/applyCoupon";
+        let apiUrl = "checkout/applyCoupon";
         const removeValue = coupon.remove ?? void 0;
         if (removeValue !== void 0) {
           couponsCodes.splice(removeValue, 1);
-          apiUrl = "/checkout/remove-coupon";
+          apiUrl = "checkout/remove-coupon";
         }
         const couponData = {
           cart: this.cart.items,
@@ -192,7 +222,10 @@ export const useCartStore = defineStore("cart", {
           code: removeValue === void 0 ? coupon.code : "",
           abndToken: this.cart.abndToken
         };
-        const response = await post(apiUrl, couponData);
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, {
+          body: couponData
+        });
         if (response?.status === "Success" && response?.data?.calculations) {
           this.cart.totals = response.data.calculations;
           if (removeValue === void 0) {
@@ -201,6 +234,18 @@ export const useCartStore = defineStore("cart", {
           this.coupon = Array.from(new Set(couponsCodes));
           useCheckoutStore().saveToCheckoutSession(response.data);
           this.errorResponseData = {};
+          this.cart = {
+            ["items"]: response?.data.cart,
+            ["totals"]: response?.data.calculations,
+            ["abndToken"]: response?.data.abndToken
+          };
+          this.lastitem = response?.data.lastitem;
+          useCheckoutStore().saveToCheckoutSession({
+            cart: response?.data,
+            calculations: response?.data.calculations,
+            abndToken: response?.data.abndToken,
+            fields: checkoutSession?.fields
+          });
           return response;
         } else {
           const errorMessage = response?.message || "Failed to apply coupon";

package/dist/runtime/stores/Checkout.d.ts

@@ -1,18 +1,21 @@
-interface PreferenceData {
+export interface PreferenceData {
     fields?: Record<string, any>;
     deliverytype?: string;
     order_no?: string;
     publishableKey?: any;
     [key: string]: any;
 }
-interface CartItem {
+export interface CartItem {
     fields?: Record<string, any>;
     deliverytype?: string;
     order_no?: string;
     publishableKey?: any;
     [key: string]: any;
 }
-interface ConfigData {
+export interface Country {
+    id: number | string;
+}
+export interface ConfigData {
     preferences?: Record<string, any>[];
     outlets?: Record<string, any>[];
     deliverytype?: string;
@@ -24,7 +27,7 @@ interface ConfigData {
     totals?: Record<string, any>;
     [key: string]: any;
 }
-interface FieldData {
+export interface FieldData {
     billing_state?: number | string;
     billing_firstname?: string | number;
     firstname?: string | number;
@@ -58,7 +61,7 @@ interface FieldData {
     quotation_no?: string;
     [key: string]: any;
 }
-interface CheckoutState {
+export interface CheckoutState {
     publishableKey: Record<string, any>;
     responseData: any[];
     config: ConfigData;
@@ -73,13 +76,4 @@ interface CheckoutState {
     PaymentErrors: any;
     loading: boolean;
 }
-export declare const useCheckoutStore: import("pinia").StoreDefinition<"checkout", CheckoutState, {}, {
-    resetState(): void;
-    paymentMethods(formData: any): Promise<any>;
-    getConfig(): Promise<void>;
-    submitCheckout(): Promise<any>;
-    confirmPayment(checkoutId: string): Promise<void>;
-    CheckUserAccount(email: string): Promise<any>;
-    saveToCheckoutSession(fieldsData: FieldData): Promise<void>;
-}>;
-export {};
+export declare const useCheckoutStore: import("pinia").StoreDefinition<"checkout", CheckoutState, {}, {}>;