@swan-admin/swan-ai-measurements 1.0.58 → 1.0.59

package/dist/auth.js

@@ -0,0 +1,133 @@
+import axios from "axios";
+import { API_ENDPOINTS, APP_AUTH_BASE_URL, APP_AUTH_WEBSOCKET_URL, APP_BASE_URL, REQUIRED_MESSAGE } from "./constants.js";
+import { checkParameters } from "./utils.js";
+/**
+ * Represents a Auth class for handling authentication operations.
+ */
+export default class Auth {
+    #socketRef;
+    /**
+     * The access key used for authentication.
+     * @type {string}
+     * @private
+     */
+    #accessKey;
+    /**
+     * Constructs a new instance of the Auth class.
+     * @param {string} accessKey - The access key used for authentication.
+     */
+    constructor(accessKey) {
+        this.#accessKey = accessKey;
+    }
+    /**
+     * Register a new user.
+     * @param {Object} params - The parameters for user registration.
+     * @param {string} params.email - The email of the user.
+     * @param {string} params.appVerifyUrl - The verification URL.
+     * @param {string} [params.gender] - Optional. The gender of the user.
+     * @param {string} [params.height] - Optional. The height of the user.
+     * @param {string} params.username - Optional. The username of the user.
+     * @returns {Promise} - The axios response promise.
+     */
+    registerUser({ email, appVerifyUrl, gender, height, username }) {
+        if (checkParameters(email, appVerifyUrl) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        let body = {
+            username,
+            email,
+            appVerifyUrl,
+        };
+        if (gender && height) {
+            body = { ...body, attributes: { gender, height } };
+        }
+        return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.REGISTER_USER}`, body, {
+            headers: { "X-Api-Key": this.#accessKey },
+        });
+    }
+    /**
+     * Verify a user token.
+     * @param {string} token
+     * @returns {Promise}
+     */
+    verifyToken = (token, accessKey) => {
+        if (checkParameters(token) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.VERIFY_USER}`, null, {
+            params: { token },
+            headers: { "X-Api-Key": this.#accessKey },
+        });
+    };
+    /**
+     * Add a user.
+     * @param {Object} params
+     * @param {string} params.scanId - The scan ID.
+     * @param {string} params.email - The email of the user.
+     * @param {string} params.name - The name of the user.
+     * @param {string} params.height - The height of the user.
+     * @param {string} params.gender - The gender of the user.
+     * @param {boolean} [params.offsetMarketingConsent] - Optional. The marketing consent offset.
+     * @returns {Promise} - The axios response promise.
+     */
+    addUser = ({ scanId, email, name, height, gender, offsetMarketingConsent }) => {
+        if (checkParameters(scanId, email, height, gender) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.ADD_USER}`, {
+            scan_id: scanId,
+            email,
+            name,
+            offsetMarketingConsent,
+            attributes: JSON.stringify({ height, gender }),
+        }, { headers: { "X-Api-Key": this.#accessKey } });
+    };
+    /**
+     * Get user details.
+     * @param {string} email
+     * @returns {Promise}
+     */
+    getUserDetail = (email) => {
+        if (checkParameters(email) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        return axios.get(`${APP_BASE_URL}${API_ENDPOINTS.GET_USER_DETAIL}/${email}`, {
+            headers: { "X-Api-Key": this.#accessKey },
+        });
+    };
+    /**
+     * Handle authentication via WebSocket.
+     * @param {Object} params
+     * @param {string} params.email - The email address of the user.
+     * @param {string} params.scanId - The scan ID associated with the user.
+     * @param {function} [params.onError] - Optional. Callback function to handle errors.
+     * @param {function} [params.onSuccess] - Optional. Callback function to handle successful authentication.
+     * @param {function} [params.onClose] - Optional. Callback function to handle the WebSocket close event.
+     * @param {function} [params.onOpen] - Optional. Callback function to handle the WebSocket open event.
+     */
+    handleAuthSocket = ({ email, scanId, onError, onSuccess, onClose, onOpen }) => {
+        if (checkParameters(email, scanId) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        this.#socketRef?.close?.();
+        this.#socketRef = new WebSocket(`${APP_AUTH_WEBSOCKET_URL}${API_ENDPOINTS.AUTH}`);
+        const detailObj = {
+            email,
+            scanId,
+        };
+        this.#socketRef.onopen = () => {
+            this.#socketRef.send(JSON.stringify(detailObj));
+            onOpen?.();
+        };
+        this.#socketRef.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            onSuccess?.(data);
+        };
+        this.#socketRef.onclose = () => {
+            onClose?.();
+        };
+        this.#socketRef.onerror = (event) => {
+            onError?.(event);
+        };
+    };
+}

package/dist/constants.js

@@ -0,0 +1,40 @@
+export const APP_BASE_URL = "https://fitview-server-staging.ft2a64raup4pg.us-east-1.cs.amazonlightsail.com";
+export const APP_AUTH_BASE_URL = "https://staging.api.getswan.co";
+export const APP_AUTH_WEBSOCKET_URL = "wss://staging.wsnotify.api.getswan.co";
+export const APP_TRY_ON_WEBSOCKET_URL = "wss://bucbzczxjk.execute-api.ap-south-1.amazonaws.com";
+export const APP_RECOMMENDATION_WEBSOCKET_URL = "wss://staging.wsnotify.api.getswan.co/scanning";
+export const APP_POSE_DETECTION_WEbSOCKET_URL = "https://posedetect-service-staging.ft2a64raup4pg.us-east-1.cs.amazonlightsail.com";
+export const UPPY_FILE_UPLOAD_ENDPOINT = {
+    UPLOAD_START: "/upload/start",
+    UPLOAD_COMPLETE: "/upload/complete",
+    UPLOAD_SIGN_PART: "/upload/signpart",
+    UPLOAD_ABORT: "/upload/abort",
+};
+export const API_ENDPOINTS = {
+    GET_USER_DETAIL: "/api/user",
+    REGISTER_USER: "/auth/register",
+    VERIFY_USER: "/auth/verify",
+    ADD_USER: "/user",
+    CUSTOM_CUSTOMER: "/customers/custom",
+    MODEL: "/model",
+    TRY_ON_SCAN: "/tryon/scan",
+    TRY_ON_IMAGE_UPLOAD: "/tryon/user-image-urls/upload",
+    TRY_ON_IMAGE_DOWNLOAD: "/tryon/user-image-urls/download",
+    TRY_ON_IMAGE_URLS: "/tryon/user-image-urls",
+    TRY_ON_RESULT_IMAGE_DOWNLOAD: "/tryon/result-image-urls/download",
+    TRY_ON: "/tryon",
+    AUTH: "/auth",
+};
+export const requiredMetaData = [
+    "gender",
+    "scan_id",
+    "email",
+    "focal_length",
+    "height",
+    "customer_store_url",
+    "scan_type",
+    "callback_url",
+    "clothes_fit",
+];
+export const REQUIRED_MESSAGE = "Please verify required parameters";
+export const REQUIRED_MESSAGE_FOR_META_DATA = "Please verify required parameters in meta data";

package/dist/custom.js

@@ -0,0 +1,49 @@
+import axios from "axios";
+import { API_ENDPOINTS, APP_AUTH_BASE_URL, REQUIRED_MESSAGE } from "./constants.js";
+import { checkParameters } from "./utils.js";
+/**
+ * Represents a Custom class for handling custom operations.
+ */
+class Custom {
+    /**
+     * The access key used for authentication.
+     * @type {string}
+     * @private
+     */
+    #accessKey;
+    /**
+     * Constructs a new instance of the Custom class.
+     * @param {string} accessKey - The access key used for authentication.
+     */
+    constructor(accessKey) {
+        this.#accessKey = accessKey;
+    }
+    /**
+     * Retrieves custom customer configuration based on the store URL.
+     * @param {string} store_url - The URL of the store.
+     * @returns {Promise} - A promise that resolves with the custom customer configuration.
+     * @throws {Error} - If required parameters are missing.
+     */
+    getCustomCustomerConfig = (store_url) => {
+        if (checkParameters(store_url) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        return axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.CUSTOM_CUSTOMER}`, {
+            params: { store_url },
+            headers: { "X-Api-Key": this.#accessKey },
+        });
+    };
+    /**
+     * Retrieves the model URL based on the model ID.
+     * @param {string} id - The ID of the model.
+     * @returns {Promise} - A promise that resolves with the model URL.
+     * @throws {Error} - If required parameters are missing.
+     */
+    getModelUrl = (id) => {
+        if (checkParameters(id) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        return axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.MODEL}/${id}`, { headers: { "X-Api-Key": this.#accessKey } });
+    };
+}
+export default Custom;

package/dist/fileUpload.js

@@ -0,0 +1,136 @@
+import { REQUIRED_MESSAGE, REQUIRED_MESSAGE_FOR_META_DATA, UPPY_FILE_UPLOAD_ENDPOINT } from "./constants.js";
+import { checkMetaDataValue, checkParameters, fetchData } from "./utils.js";
+/**
+ * Class representing a file uploader using Uppy for multipart uploads.
+ */
+class FileUpload {
+    /**
+     * The Uppy instance.
+     * @type {Object}
+     * @private
+     */
+    #uppyIns;
+    /**
+     * Reference to the Uppy module.
+     * @type {Object}
+     * @private
+     */
+    #Uppy;
+    /**
+     * Reference to the AwsS3Multipart module.
+     * @type {Object}
+     * @private
+     */
+    #AwsS3Multipart;
+    /**
+     * The access key used for authentication.
+     * @type {string}
+     * @private
+     */
+    #accessKey;
+    /**
+     * Constructs a new instance of the FileUpload class.
+     * @param {string} accessKey - The access key used for authentication.
+     */
+    constructor(accessKey) {
+        this.initializeModules();
+        this.#accessKey = accessKey;
+    }
+    /**
+     * Asynchronously initializes the Uppy and AwsS3Multipart modules.
+     * @private
+     */
+    async initializeModules() {
+        this.#Uppy = (await import("@uppy/core")).default;
+        this.#AwsS3Multipart = (await import("@uppy/aws-s3-multipart")).default;
+    }
+    /**
+     * Uploads a file with optional metadata and scan ID.
+     * @param {Object} params - The parameters for file upload.
+     * @param {File} params.file - The file to upload.
+     * @param {Object} params.objMetaData - Optional. Metadata associated with the file.
+     * @param {string} params.scanId - Optional. The ID of the scan.
+     * @returns {Promise} - A promise that resolves when the file is uploaded successfully.
+     * @throws {Error} - If required parameters are missing or metadata value is invalid.
+     */
+    async uploadFile({ file, objMetaData, scanId }) {
+        if (checkParameters(file, objMetaData, scanId) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        if (checkMetaDataValue(objMetaData) === false) {
+            throw new Error(REQUIRED_MESSAGE_FOR_META_DATA);
+        }
+        if (!this.#Uppy || !this.#AwsS3Multipart) {
+            await this.initializeModules();
+        }
+        return new Promise((resolve, reject) => {
+            if (this.#uppyIns) {
+                this.#uppyIns.close();
+            }
+            this.#uppyIns = new this.#Uppy({ autoProceed: true });
+            this.#uppyIns.use(this.#AwsS3Multipart, {
+                limit: 10,
+                retryDelays: [0, 1000, 3000, 5000],
+                getChunkSize: () => 5 * 1024 * 1024,
+                createMultipartUpload: (file) => {
+                    const objectKey = `${scanId}.${file.extension}`;
+                    return fetchData({
+                        path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_START,
+                        apiKey: this.#accessKey,
+                        body: {
+                            objectKey,
+                            contentType: file.type,
+                            objectMetadata: objMetaData,
+                        },
+                    });
+                },
+                completeMultipartUpload: (file, { uploadId, key, parts }) => fetchData({
+                    path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_COMPLETE,
+                    apiKey: this.#accessKey,
+                    body: {
+                        uploadId,
+                        objectKey: key,
+                        parts,
+                        originalFileName: file.name,
+                    },
+                }),
+                signPart: (file, partData) => fetchData({
+                    path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_SIGN_PART,
+                    apiKey: this.#accessKey,
+                    body: {
+                        objectKey: partData.key,
+                        uploadId: partData.uploadId,
+                        partNumber: partData.partNumber,
+                    },
+                }),
+                abortMultipartUpload: (file, { uploadId, key }) => fetchData({
+                    path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_ABORT,
+                    apiKey: this.#accessKey,
+                    body: {
+                        uploadId,
+                        objectKey: key,
+                        originalFileName: file.name,
+                    },
+                }),
+            });
+            this.#uppyIns.addFile({
+                source: "manual",
+                name: file.name,
+                type: file.type,
+                data: file,
+            });
+            this.#uppyIns.on("upload-error", (file, error, response) => {
+                reject(error);
+            });
+            this.#uppyIns.on("upload-success", () => {
+                resolve({ message: "file uploaded successfully" });
+            });
+            this.#uppyIns.on("complete", (result) => {
+                if (this.#uppyIns) {
+                    this.#uppyIns.close();
+                }
+            });
+        });
+    }
+}
+export default FileUpload;

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import Auth from "./auth";
+import Custom from "./custom";
+import FileUpload from "./fileUpload";
+import Measurement from "./measurement";
+import PoseDetection from "./poseDetection";
+import TryOn from "./tryOn";
+
+export default class Swan {
+  constructor(accessKey: string);
+
+  auth: Auth;
+  custom: Custom;
+  fileUpload: FileUpload;
+  measurement: Measurement;
+  poseDetection: PoseDetection;
+  tryOn: TryOn;
+
+  #private;
+}

package/dist/index.js

@@ -0,0 +1,19 @@
+import Auth from "./auth.js";
+import Custom from "./custom.js";
+import FileUpload from "./fileUpload.js";
+import Measurement from "./measurement.js";
+import PoseDetection from "./poseDetection.js";
+import TryOn from "./tryOn.js";
+class Swan {
+    #accessKey;
+    constructor(accessKey) {
+        this.#accessKey = accessKey;
+    }
+    auth = new Auth(this.#accessKey);
+    custom = new Custom(this.#accessKey);
+    fileUpload = new FileUpload(this.#accessKey);
+    measurement = new Measurement(this.#accessKey);
+    poseDetection = new PoseDetection(this.#accessKey);
+    tryOn = new TryOn(this.#accessKey);
+}
+export default Swan;

package/dist/measurement.js

@@ -0,0 +1,198 @@
+import axios from "axios";
+import { API_ENDPOINTS, APP_AUTH_BASE_URL, APP_RECOMMENDATION_WEBSOCKET_URL, APP_TRY_ON_WEBSOCKET_URL, REQUIRED_MESSAGE } from "./constants.js";
+import { checkParameters } from "./utils.js";
+/**
+ * Class representing measurement-related functionality.
+ */
+class Measurement {
+    #tryOnSocketRef = null;
+    #measurementSocketRef = null;
+    #timerPollingRef = null;
+    #timerWaitingRef = null;
+    #count = 1;
+    #accessKey;
+    /**
+     * Constructs a new instance of the Measurement class.
+     * @param {string} accessKey - The access key used for authentication.
+     */
+    constructor(accessKey) {
+        this.#accessKey = accessKey;
+    }
+    /**
+     * Retrieves the measurement status for a given scan ID.
+     * @param {string} scanId - The ID of the scan.
+     * @returns {Promise} - The axios response promise.
+     * @throws {Error} - If the required parameter is missing.
+     */
+    getMeasurementStatus(scanId) {
+        if (checkParameters(scanId) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        const url = `${APP_AUTH_BASE_URL}/measurements?scanId=${scanId}`;
+        return axios.get(url, {
+            headers: { "X-Api-Key": this.#accessKey },
+        });
+    }
+    /**
+     * Retrieves the try-on measurements for a given scan ID, shop domain, and product name.
+     * @param {Object} params - The parameters for the try-on measurements.
+     * @param {string} params.scanId - The ID of the scan.
+     * @param {string} params.shopDomain - The shop domain.
+     * @param {string} params.productName - The product name.
+     * @returns {Promise} - The axios response promise.
+     * @throws {Error} - If the required parameters are missing.
+     */
+    getTryOnMeasurements({ scanId, shopDomain, productName }) {
+        if (checkParameters(scanId, shopDomain, productName) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        const tryOnUrl = `${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON_SCAN}/${scanId}/shop/${shopDomain}/product/${productName}`;
+        return axios.get(tryOnUrl, { headers: { "X-Api-Key": this.#accessKey } });
+    }
+    /**
+     * Handles the try-on WebSocket connection.
+     * @param {Object} params - The parameters for the WebSocket connection.
+     * @param {string} params.shopDomain - The shop domain.
+     * @param {string} params.scanId - The ID of the scan.
+     * @param {string} params.productName - The product name.
+     * @param {function} [params.onError] - Optional. Callback function to handle errors.
+     * @param {function} [params.onSuccess] - Optional. Callback function to handle successful messages.
+     * @param {function} [params.onClose] - Optional. Callback function to handle WebSocket close event.
+     * @param {function} [params.onOpen] - Optional. Callback function to handle WebSocket open event.
+     */
+    handleTryOnSocket({ shopDomain, scanId, productName, onError, onSuccess, onClose, onOpen }) {
+        if (checkParameters(shopDomain, scanId, productName) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        this.#tryOnSocketRef?.close();
+        const url = `${APP_TRY_ON_WEBSOCKET_URL}/develop?store_url=${shopDomain}&product_name=${productName}&scan_id=${scanId}`;
+        this.#tryOnSocketRef = new WebSocket(url);
+        this.#tryOnSocketRef.onopen = () => {
+            onOpen?.();
+        };
+        this.#tryOnSocketRef.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            if (data?.tryOnProcessStatus === "available") {
+                onSuccess?.(data);
+            }
+            else {
+                onError?.({ message: "failed to get image urls" });
+            }
+        };
+        this.#tryOnSocketRef.onclose = () => {
+            onClose?.();
+        };
+        this.#tryOnSocketRef.onerror = (event) => {
+            onError?.(event);
+        };
+    }
+    /**
+     * Checks the measurement status and handles polling.
+     * @param {Object} params - The parameters for checking measurements.
+     * @param {string} params.scanId - The ID of the scan.
+     * @param {function} [params.onSuccess] - Optional. Callback function to handle successful status check.
+     * @param {function} [params.onError] - Optional. Callback function to handle errors.
+     * @private
+     */
+    async #getMeasurementsCheck({ scanId, onSuccess, onError }) {
+        try {
+            const res = await this.getMeasurementStatus(scanId);
+            if (res?.data && res?.data?.[0]?.isMeasured === true) {
+                onSuccess?.(res?.data);
+                clearInterval(this.#timerPollingRef);
+            }
+            else {
+                if (this.#count < 8) {
+                    this.#count++;
+                    this.#handlePolling({ scanId, onSuccess, onError });
+                }
+                else {
+                    this.#count = 1;
+                    clearInterval(this.#timerPollingRef);
+                    onError?.({ scanStatus: "failed", message: "Scan not found", isMeasured: false });
+                }
+            }
+        }
+        catch (e) {
+            clearInterval(this.#timerPollingRef);
+            onError?.(e);
+        }
+    }
+    /**
+     * Handles polling for measurements.
+     * @param {Object} params - The parameters for polling.
+     * @param {string} params.scanId - The ID of the scan.
+     * @param {function} [params.onSuccess] - Optional. Callback function to handle successful polling.
+     * @param {function} [params.onError] - Optional. Callback function to handle errors.
+     * @private
+     */
+    #handlePolling({ scanId, onSuccess, onError }) {
+        clearInterval(this.#timerPollingRef);
+        this.#timerPollingRef = setTimeout(() => {
+            this.#getMeasurementsCheck({ scanId, onSuccess, onError });
+        }, this.#count * 5000);
+    }
+    /**
+     * Disconnects the measurement WebSocket and clears the timeout.
+     * @private
+     */
+    #disconnectSocket() {
+        this.#measurementSocketRef?.close();
+        clearTimeout(this.#timerWaitingRef);
+    }
+    /**
+     * Handles the timeout for the measurement WebSocket.
+     * @param {Object} params - The parameters for handling timeout.
+     * @param {string} params.scanId - The ID of the scan.
+     * @param {function} [params.onSuccess] - Optional. Callback function to handle successful timeout.
+     * @param {function} [params.onError] - Optional. Callback function to handle errors.
+     * @private
+     */
+    #handleTimeOut({ scanId, onSuccess, onError }) {
+        this.#count = 1;
+        this.#timerWaitingRef = setTimeout(() => {
+            this.#handlePolling({ scanId, onSuccess, onError });
+            this.#disconnectSocket();
+        }, 2 * 60000);
+    }
+    /**
+     * Handles the measurement WebSocket connection.
+     * @param {Object} params - The parameters for the WebSocket connection.
+     * @param {string} params.scanId - The ID of the scan.
+     * @param {function} [params.onError] - Optional. Callback function to handle errors.
+     * @param {function} [params.onSuccess] - Optional. Callback function to handle successful messages.
+     * @param {function} [params.onClose] - Optional. Callback function to handle WebSocket close event.
+     * @param {function} [params.onOpen] - Optional. Callback function to handle WebSocket open event.
+     */
+    handleMeasurementSocket({ scanId, onError, onSuccess, onClose, onOpen }) {
+        if (checkParameters(scanId) === false) {
+            throw new Error(REQUIRED_MESSAGE);
+        }
+        setTimeout(() => {
+            this.#disconnectSocket();
+            const url = `${APP_RECOMMENDATION_WEBSOCKET_URL}?scanId=${scanId}`;
+            this.#measurementSocketRef = new WebSocket(url);
+            this.#measurementSocketRef.onopen = () => {
+                onOpen?.();
+                this.#handleTimeOut({ scanId, onSuccess, onError });
+            };
+            this.#measurementSocketRef.onmessage = (event) => {
+                const data = JSON.parse(event.data);
+                if (data?.code === 200 && data?.scanStatus === "success") {
+                    onSuccess?.(data);
+                }
+                else {
+                    onError?.(data);
+                }
+                clearTimeout(this.#timerWaitingRef);
+            };
+            this.#measurementSocketRef.onclose = () => {
+                onClose?.();
+            };
+            this.#measurementSocketRef.onerror = (event) => {
+                onError?.(event);
+            };
+        }, 5000);
+    }
+}
+export default Measurement;

package/dist/poseDetection.js

@@ -0,0 +1,72 @@
+import { io } from "socket.io-client";
+import { APP_POSE_DETECTION_WEbSOCKET_URL } from "./constants.js";
+/**
+ * Class representing pose detection functionality.
+ */
+class PoseDetection {
+    #socketRef = null;
+    #accessKey;
+    /**
+     * Constructs a new instance of the PoseDetection class.
+     * @param {string} accessKey - The access key used for authentication.
+     */
+    constructor(accessKey) {
+        this.#accessKey = accessKey;
+    }
+    /**
+     * Connects to the pose detection WebSocket server.
+     * @returns {Promise<string>} - A promise that resolves with the socket ID on successful connection.
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.#socketRef = io.connect(APP_POSE_DETECTION_WEbSOCKET_URL);
+            this.#socketRef?.on("connect", () => {
+                resolve(this.#socketRef.id);
+            });
+            this.#socketRef?.on("connect_error", (err) => reject(err));
+        });
+    }
+    /**
+     * Emits a video frame to the pose detection server.
+     * @param {Object} params - The parameters for emitting the video frame.
+     * @param {string} params.image - The image data.
+     * @param {string} params.scanId - The unique scan ID.
+     * @throws {Error} - If the socket is not connected.
+     */
+    videoEmit({ image, scanId }) {
+        if (!this.#socketRef) {
+            throw new Error("Socket is not connected");
+        }
+        this.#socketRef.emit("video", {
+            image,
+            user_unique_key: scanId,
+        });
+    }
+    /**
+     * Disconnects from the pose detection WebSocket server.
+     */
+    disconnect() {
+        this.#socketRef?.disconnect?.();
+    }
+    /**
+     * Registers a callback function to handle pose status updates.
+     * @param {function} callBack - The callback function to handle pose status updates.
+     * @throws {Error} - If the socket is not connected.
+     */
+    poseStatus(callBack) {
+        if (!this.#socketRef) {
+            throw new Error("Socket is not connected");
+        }
+        this.#socketRef.on("pose_status", (data) => {
+            callBack?.(data);
+        });
+    }
+    /**
+     * Checks if the socket is connected.
+     * @returns {boolean} - True if the socket is connected, false otherwise.
+     */
+    connected() {
+        return !!this.#socketRef?.connected;
+    }
+}
+export default PoseDetection;