@tapsilat/tapsilat-js 2026.1.14 → 2026.6.17

package/dist/index.cjs

@@ -612,7 +612,7 @@ class HttpClient {
             ...config?.headers,
         });
         // Set content type for requests with body
-        if (body && method !== "GET" && method !== "DELETE") {
+        if (body && method !== "GET") {
             if (!(body instanceof FormData)) {
                 headers.set("Content-Type", "application/json");
             }
@@ -622,8 +622,8 @@ class HttpClient {
             headers,
             ...config,
         };
-        // Add body for non-GET/DELETE requests
-        if (body && method !== "GET" && method !== "DELETE") {
+        // Add body for non-GET requests
+        if (body && method !== "GET") {
             if (body instanceof FormData) {
                 options.body = body;
             }
@@ -1131,7 +1131,7 @@ function validateInstallments(installments) {
             originalInput: String(originalInput)
         };
     }
-    let installmentArray = [];
+    let installmentArray;
     try {
         if (typeof installments === 'number') {
             // Single number
@@ -1423,6 +1423,110 @@ class TapsilatSDK {
         this.configManager = new ConfigManager(config);
         this.httpClient = new HttpClient(this.configManager.getInternalConfig());
     }
+    /**
+     * Access to order operations
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get orders() {
+        return {
+            create: (request) => this.createOrder(request),
+            get: (referenceId) => this.getOrder(referenceId),
+            list: (params) => this.getOrders(params),
+            cancel: (referenceId) => this.cancelOrder(referenceId),
+            status: (referenceId) => this.getOrderStatus(referenceId),
+            refund: (request) => this.refundOrder(request),
+            refundAll: (referenceId) => this.refundAllOrder(referenceId),
+            paymentDetails: (request) => this.getOrderPaymentDetails(request),
+            paymentDetailsById: (referenceId) => this.getOrderPaymentDetailsById(referenceId),
+            callback: (id) => this.orderCallback(id),
+            updatePaymentOptions: (request) => this.updatePaymentOptions(request),
+            splitItemPayment: (request) => this.splitOrderItemPayment(request),
+            vposQuery: (id) => this.orderVposQuery(id),
+            byConversationId: (conversationId) => this.getOrderByConversationId(conversationId),
+            transactions: (referenceId) => this.getOrderTransactions(referenceId),
+            submerchants: (params) => this.getOrderSubmerchants(params),
+            checkoutUrl: (referenceId) => this.getCheckoutUrl(referenceId),
+            accounting: (request) => this.orderAccounting(request),
+            postAuth: (request) => this.orderPostAuth(request),
+            manualCallback: (referenceId, conversationId) => this.orderManualCallback(referenceId, conversationId),
+            relatedUpdate: (referenceId, relatedReferenceId) => this.orderRelatedUpdate(referenceId, relatedReferenceId),
+            addBasketItem: (request) => this.addBasketItem(request),
+            removeBasketItem: (request) => this.removeBasketItem(request),
+            updateBasketItem: (request) => this.updateBasketItem(request),
+            createTerm: (request) => this.createOrderTerm(request),
+            updateTerm: (request) => this.updateOrderTerm(request),
+            deleteTerm: (request) => this.deleteOrderTerm(request),
+            refundTerm: (request) => this.refundOrderTerm(request),
+            getTerm: (termReferenceId) => this.getOrderTerm(termReferenceId),
+            terminateTerm: (request) => this.terminateOrderTerm(request),
+            terminate: (request) => this.terminateOrder(request),
+        };
+    }
+    /**
+     * Access to subscription operations
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get subscriptions() {
+        return {
+            create: (request) => this.createSubscription(request),
+            get: (request) => this.getSubscription(request),
+            list: (params) => this.listSubscriptions(params),
+            cancel: (request) => this.cancelSubscription(request),
+            redirect: (request) => this.redirectSubscription(request),
+        };
+    }
+    /**
+     * Access to organization operations
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get organization() {
+        return {
+            settings: () => this.getOrganizationSettings(),
+            callback: () => this.getOrganizationCallback(),
+            updateCallback: (request) => this.updateOrganizationCallback(request),
+            createBusiness: (request) => this.createOrganizationBusiness(request),
+            currencies: () => this.getOrganizationCurrencies(),
+            getLimitUser: (request) => this.getOrganizationLimitUser(request),
+            setLimitUser: (request) => this.setOrganizationLimitUser(request),
+            limits: () => this.getOrganizationLimits(),
+            meta: (name) => this.getOrganizationMeta(name),
+            scopes: () => this.getOrganizationScopes(),
+            suborganizations: (params) => this.getOrganizationSuborganizations(params),
+            createUser: (request) => this.createOrganizationUser(request),
+            verifyUser: (request) => this.verifyOrganizationUser(request),
+            verifyUserMobile: (request) => this.verifyOrganizationUserMobile(request),
+            listVpos: (request) => this.listOrganizationVpos(request),
+            currencyPresets: () => this.getOrganizationCurrencyPresets(),
+            suborganizationDetails: (id) => this.getOrganizationSuborganizationDetails(id),
+            suborganizationSubmerchants: (id) => this.getOrganizationSuborganizationSubmerchants(id),
+        };
+    }
+    /**
+     * Access to system operations
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get system() {
+        return {
+            orderStatuses: () => this.getSystemOrderStatuses(),
+            basketItemTypes: () => this.getSystemBasketItemTypes(),
+            errorCodes: () => this.getSystemErrorCodes(),
+            paymentTermStatuses: () => this.getSystemPaymentTermStatuses(),
+            productTypes: () => this.getSystemProductTypes(),
+            shortcutTypes: () => this.getSystemShortcutTypes(),
+            transactionPaymentTypes: () => this.getSystemTransactionPaymentTypes(),
+            transactionPurposes: () => this.getSystemTransactionPurposes(),
+            transactionStatuses: () => this.getSystemTransactionStatuses(),
+        };
+    }
+    /**
+     * Access to webhook operations
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get webhooks() {
+        return {
+            verify: (payload, signature, secret) => this.verifyWebhook(payload, signature, secret),
+        };
+    }
     // ORDER CREATION
     // Summary: Create new payment order and get checkout URL
     // Description: Initiates payment process with buyer info and returns secure checkout URL
@@ -1457,10 +1561,10 @@ class TapsilatSDK {
      * @param {string} [orderRequest.payment_success_url] - URL to redirect after successful payment
      * @param {string} [orderRequest.payment_failure_url] - URL to redirect after failed payment
      * @param {number[]} [orderRequest.enabled_installments] - Allowed installment counts
-     * @param {Record<string, unknown>} [orderRequest.metadata] - Additional custom data
+     * @param {OrderMetadata[]} [orderRequest.metadata] - Additional custom key/value data
      *
      * @returns {Promise<OrderCreateResponse>} Promise resolving to order creation response
-     * @returns {string} OrderCreateResponse.order_id - Internal order identifier
+     * @returns {string} [OrderCreateResponse.id] - Internal order identifier
      * @returns {string} OrderCreateResponse.reference_id - Unique order reference for tracking
      * @returns {string} [OrderCreateResponse.checkout_url] - Payment page URL for customer
      * @returns {string} [OrderCreateResponse.conversation_id] - Echo of provided conversation ID
@@ -1516,16 +1620,6 @@ class TapsilatSDK {
         if (!isValidEmail(buyer.email)) {
             throw new TapsilatValidationError("Buyer email must be a valid email address", { provided: buyer.email });
         }
-        // Validate basket items
-        if (!orderRequest.basket_items ||
-            !Array.isArray(orderRequest.basket_items) ||
-            orderRequest.basket_items.length === 0) {
-            throw new TapsilatValidationError("Basket items are required and must be a non-empty array");
-        }
-        // Validate billing address
-        if (!orderRequest.billing_address) {
-            throw new TapsilatValidationError("Billing address is required");
-        }
         try {
             // Make the API request
             const createOrderResponse = await this.httpClient.post("/order/create", orderRequest);
@@ -1547,7 +1641,7 @@ class TapsilatSDK {
      * @description Handles accounting operations for a specific order using its reference ID.
      *
      * @param {OrderAccountingRequest} request - Accounting request details
-     * @returns {Promise<APIResponse<unknown>>} Promise resolving to the accounting response
+     * @returns {Promise<OrderAccountingResponse>} Promise resolving to the accounting response
      * @throws {TapsilatValidationError} When input validation fails
      * @throws {TapsilatError} When API returns an error response
      */
@@ -1556,8 +1650,8 @@ class TapsilatSDK {
             throw new TapsilatValidationError("Order reference ID is required and must be a non-empty string", { provided: request.order_reference_id });
         }
         try {
-            const response = await this.httpClient.post("/order/accounting", request);
-            return handleResponse(response, "Order accounting");
+            const orderAccountingResponse = await this.httpClient.post("/order/accounting", request);
+            return handleResponse(orderAccountingResponse, "Order accounting");
         }
         catch (error) {
             return handleError(error, "order accounting");
@@ -1573,7 +1667,7 @@ class TapsilatSDK {
      * @description Handles post-authorization operations for a specific order.
      *
      * @param {OrderPostAuthRequest} request - Post-authorization request details
-     * @returns {Promise<APIResponse<unknown>>} Promise resolving to the post-auth response
+     * @returns {Promise<OrderPostAuthResponse>} Promise resolving to the post-auth response
      * @throws {TapsilatValidationError} When input validation fails
      * @throws {TapsilatError} When API returns an error response
      */
@@ -1587,8 +1681,8 @@ class TapsilatSDK {
             });
         }
         try {
-            const response = await this.httpClient.post("/order/postauth", request);
-            return handleResponse(response, "Order post-auth");
+            const orderPostAuthResponse = await this.httpClient.post("/order/postauth", request);
+            return handleResponse(orderPostAuthResponse, "Order post-auth");
         }
         catch (error) {
             return handleError(error, "order post-auth");
@@ -1603,18 +1697,122 @@ class TapsilatSDK {
      * @summary Retrieve system order statuses
      * @description Gets a list of all possible order statuses in the system.
      *
-     * @returns {Promise<APIResponse<unknown>>} Promise resolving to system order statuses
+     * @returns {Promise<GetSystemOrderStatusesResponse>} Promise resolving to system order statuses
      * @throws {TapsilatError} When API returns an error response
      */
     async getSystemOrderStatuses() {
         try {
-            const response = await this.httpClient.get("/system/order-statuses");
-            return handleResponse(response, "Get system order statuses");
+            const getSystemOrderStatusesResponse = await this.httpClient.get("/system/order-statuses");
+            return handleResponse(getSystemOrderStatusesResponse, "Get system order statuses");
         }
         catch (error) {
             return handleError(error, "get system order statuses");
         }
     }
+    /**
+     * Retrieves system basket item types.
+     * Based on `get_system_basket_item_types` from Python SDK.
+     */
+    async getSystemBasketItemTypes() {
+        try {
+            const response = await this.httpClient.get("/system/basket-item-types");
+            return handleResponse(response, "Get system basket item types");
+        }
+        catch (error) {
+            return handleError(error, "get system basket item types");
+        }
+    }
+    /**
+     * Retrieves system error codes.
+     * Based on `get_system_error_codes` from Python SDK.
+     */
+    async getSystemErrorCodes() {
+        try {
+            const response = await this.httpClient.get("/system/error-codes");
+            return handleResponse(response, "Get system error codes");
+        }
+        catch (error) {
+            return handleError(error, "get system error codes");
+        }
+    }
+    /**
+     * Retrieves system payment term statuses.
+     * Based on `get_system_payment_term_statuses` from Python SDK.
+     */
+    async getSystemPaymentTermStatuses() {
+        try {
+            const response = await this.httpClient.get("/system/payment-term-statuses");
+            return handleResponse(response, "Get system payment term statuses");
+        }
+        catch (error) {
+            return handleError(error, "get system payment term statuses");
+        }
+    }
+    /**
+     * Retrieves system product types.
+     * Based on `get_system_product_types` from Python SDK.
+     */
+    async getSystemProductTypes() {
+        try {
+            const response = await this.httpClient.get("/system/product-types");
+            return handleResponse(response, "Get system product types");
+        }
+        catch (error) {
+            return handleError(error, "get system product types");
+        }
+    }
+    /**
+     * Retrieves system shortcut types.
+     * Based on `get_system_shortcut_types` from Python SDK.
+     */
+    async getSystemShortcutTypes() {
+        try {
+            const response = await this.httpClient.get("/system/shortcut-types");
+            return handleResponse(response, "Get system shortcut types");
+        }
+        catch (error) {
+            return handleError(error, "get system shortcut types");
+        }
+    }
+    /**
+     * Retrieves system transaction payment types.
+     * Based on `get_system_transaction_payment_types` from Python SDK.
+     */
+    async getSystemTransactionPaymentTypes() {
+        try {
+            const response = await this.httpClient.get("/system/transaction-payment-types");
+            return handleResponse(response, "Get system transaction payment types");
+        }
+        catch (error) {
+            return handleError(error, "get system transaction payment types");
+        }
+    }
+    /**
+     * Retrieves system transaction purposes.
+     * Based on `get_system_transaction_purposes` from Python SDK.
+     */
+    async getSystemTransactionPurposes() {
+        try {
+            const response = await this.httpClient.get("/system/transaction-purposes");
+            return handleResponse(response, "Get system transaction purposes");
+        }
+        catch (error) {
+            return handleError(error, "get system transaction purposes");
+        }
+    }
+    /**
+     * Retrieves system transaction statuses.
+     * Based on `get_system_transaction_statuses` from Python SDK.
+     */
+    async getSystemTransactionStatuses() {
+        try {
+            const response = await this.httpClient.get("/system/transaction-statuses");
+            return handleResponse(response, "Get system transaction statuses");
+        }
+        catch (error) {
+            return handleError(error, "get system transaction statuses");
+        }
+    }
     // ORDER RETRIEVAL BY REFERENCE ID
     // Summary: Get complete order details and information
     // Description: Retrieves full order data including buyer info, amounts, and current status
@@ -1687,6 +1885,10 @@ class TapsilatSDK {
                     throw new TapsilatValidationError("Items per page must be greater than 0", { provided: params.per_page });
                 }
             }
+            // Check if status is defined
+            if (params.status !== undefined && !isInteger(params.status)) {
+                throw new TapsilatValidationError("Status must be an integer", { provided: params.status });
+            }
             // Make the API request
             const getOrdersResponse = await this.httpClient.get("/order/list", { params: params });
             // Use our generic response handler
@@ -1712,23 +1914,28 @@ class TapsilatSDK {
      * @throws {TapsilatError} When API returns an error response or order cannot be canceled
      */
     async cancelOrder(referenceId) {
-        // Validate referenceId
         if (!isNonEmptyString(referenceId)) {
             throw new TapsilatValidationError("Order referenceId is required and must be a non-empty string", { provided: referenceId });
         }
-        const cancelOrderResponse = await this.httpClient.post("/order/cancel", {
-            reference_id: referenceId,
-        });
-        // Check if API call was successful
-        if (!cancelOrderResponse.success) {
-            throw new TapsilatError(cancelOrderResponse.error?.message ||
-                "Order cancellation API call failed", cancelOrderResponse.error?.code || "CANCELLATION_API_FAILED");
+        try {
+            const cancelOrderPayload = {
+                reference_id: referenceId,
+            };
+            const cancelOrderResponse = await this.httpClient.post("/order/cancel", cancelOrderPayload);
+            // Check if API call was successful
+            if (!cancelOrderResponse.success) {
+                throw new TapsilatError(cancelOrderResponse.error?.message ||
+                    "Order cancellation API call failed", cancelOrderResponse.error?.code || "CANCELLATION_API_FAILED");
+            }
+            // Check if response data exists
+            if (!cancelOrderResponse.data) {
+                throw new TapsilatError("Order cancellation response data is missing", "CANCELLATION_DATA_MISSING");
+            }
+            return cancelOrderResponse.data;
         }
-        // Check if response data exists
-        if (!cancelOrderResponse.data) {
-            throw new TapsilatError("Order cancellation response data is missing", "CANCELLATION_DATA_MISSING");
+        catch (error) {
+            return handleError(error, "order cancellation");
         }
-        return cancelOrderResponse.data;
     }
     // ORDER STATUS RETRIEVAL
     // Summary: Retrieves real-time payment status and tracking information for a specific order
@@ -1739,12 +1946,12 @@ class TapsilatSDK {
      * @summary Retrieves real-time payment status and tracking information for a specific order
      * @description
      * Queries the Tapsilat payment platform to retrieve the current status of an order using its
-     * unique reference ID. This method provides real-time information about payment progress,
-     * completion status, and last update timestamp. It's essential for tracking payment flow
+     * unique reference ID. This method provides real-time information about payment processing
+     * status and error code (if returned by the API). It's essential for tracking payment flow
      * and implementing proper order state management in your application.
      *
-     * The status information includes payment state (CREATED, PENDING_PAYMENT, COMPLETED, CANCELLED),
-     * last update timestamp, and any relevant status metadata. This method should be used to:
+     * The status information includes payment state and API-level error code metadata.
+     * This method should be used to:
      * - Check if a payment has been completed after redirecting from checkout
      * - Monitor payment status for pending transactions
      * - Verify order state before fulfilling goods/services
@@ -1753,13 +1960,11 @@ class TapsilatSDK {
      * @param {string} referenceId - Unique order reference identifier from order creation
      *
      * @returns {Promise<OrderStatusResponse>} Promise resolving to current order status information
-     * @returns {string} OrderStatusResponse.referenceId - Echo of the provided reference ID
-     * @returns {string} OrderStatusResponse.status - Current payment status (CREATED, PENDING_PAYMENT, COMPLETED, CANCELLED, FAILED)
-     * @returns {string} OrderStatusResponse.lastUpdatedAt - ISO 8601 timestamp of last status change
+     * @returns {string} [OrderStatusResponse.error_code] - API-level error code when present
+     * @returns {string} [OrderStatusResponse.status] - Current payment processing status
      *
      * @throws {TapsilatValidationError} When input validation fails:
      *   - Reference ID is null, undefined, or empty string
-     *   - Reference ID format is invalid (should match order ID pattern)
      * @throws {TapsilatNetworkError} When network request fails:
      *   - Connection timeout during status check
      *   - DNS resolution failure
@@ -1800,14 +2005,19 @@ class TapsilatSDK {
      * @throws {TapsilatError} When API returns an error response or refund fails
      */
     async refundOrder(refundData) {
-        const refundOrderResponse = await this.httpClient.post("/order/refund", refundData);
-        if (!refundOrderResponse.success) {
-            throw new TapsilatError(refundOrderResponse.error?.message || "Order refund failed", refundOrderResponse.error?.code || "REFUND_FAILED");
+        try {
+            const refundOrderResponse = await this.httpClient.post("/order/refund", refundData);
+            if (!refundOrderResponse.success) {
+                throw new TapsilatError(refundOrderResponse.error?.message || "Order refund failed", refundOrderResponse.error?.code || "REFUND_FAILED");
+            }
+            if (!refundOrderResponse.data) {
+                throw new TapsilatError("Order refund response data is missing", "REFUND_DATA_MISSING");
+            }
+            return refundOrderResponse.data;
         }
-        if (!refundOrderResponse.data) {
-            throw new TapsilatError("Order refund response data is missing", "REFUND_DATA_MISSING");
+        catch (error) {
+            return handleError(error, "order refund");
         }
-        return refundOrderResponse.data;
     }
     // ORDER FULL REFUND OPERATIONS
     // Summary: Process full refund for a completed order
@@ -1824,48 +2034,109 @@ class TapsilatSDK {
      * @throws {TapsilatError} When API returns an error response or full refund fails
      */
     async refundAllOrder(referenceId) {
-        const refundAllOrderResponse = await this.httpClient.post("/order/refund-all", {
-            reference_id: referenceId,
-        });
-        if (!refundAllOrderResponse.success) {
-            throw new TapsilatError(refundAllOrderResponse.error?.message || "Full order refund failed", refundAllOrderResponse.error?.code || "FULL_REFUND_FAILED");
+        try {
+            const refundAllPayload = {
+                reference_id: referenceId,
+            };
+            const refundAllOrderResponse = await this.httpClient.post("/order/refund-all", refundAllPayload);
+            if (!refundAllOrderResponse.success) {
+                throw new TapsilatError(refundAllOrderResponse.error?.message || "Full order refund failed", refundAllOrderResponse.error?.code || "FULL_REFUND_FAILED");
+            }
+            if (!refundAllOrderResponse.data) {
+                throw new TapsilatError("Full order refund response data is missing", "FULL_REFUND_DATA_MISSING");
+            }
+            return refundAllOrderResponse.data;
         }
-        if (!refundAllOrderResponse.data) {
-            throw new TapsilatError("Full order refund response data is missing", "FULL_REFUND_DATA_MISSING");
+        catch (error) {
+            return handleError(error, "full order refund");
         }
-        return refundAllOrderResponse.data;
     }
     // ORDER PAYMENT DETAILS
     // Summary: Retrieve detailed payment transaction information for an order
     // Description: Gets payment method, amount, status, and card info for order transactions
     /**
-     * Retrieves the payment details for an order.
+     * Retrieves the payment details for an order via POST request.
      * Based on `get_order_payment_details` from the Python SDK.
-     *
-     * @summary Retrieve detailed payment transaction information for an order
-     * @description Gets payment method, amount, status, and card info for order transactions.
-     *
-     * @param referenceId - The unique identifier of the order.
-     * @param conversationId - Optional conversation ID for more specific querying.
-     * @returns Promise resolving to a list of payment details.
-     * @throws {TapsilatValidationError} When referenceId is invalid
-     * @throws {TapsilatError} When API returns an error response or payment details are missing
      */
-    async getOrderPaymentDetails(referenceId, conversationId) {
+    async getOrderPaymentDetails(request) {
+        try {
+            const getOrderPaymentDetailsResponse = await this.httpClient.post("/order/payment-details", request);
+            return handleResponse(getOrderPaymentDetailsResponse, "Order payment details");
+        }
+        catch (error) {
+            return handleError(error, "order payment details");
+        }
+    }
+    /**
+     * Retrieves the payment details for an order by ID.
+     * Based on `get_order_payment_details_by_id` from the Python SDK.
+     */
+    async getOrderPaymentDetailsById(referenceId) {
         if (!isNonEmptyString(referenceId))
             throw new TapsilatValidationError("Reference ID is required and must be a non-empty string");
-        const getOrderPaymentDetailsResponse = conversationId
-            ? await this.httpClient.post("/order/payment-details", {
-                conversation_id: conversationId,
-            })
-            : await this.httpClient.get(`/order/${referenceId}/payment-details`);
-        if (!getOrderPaymentDetailsResponse.success)
-            throw new TapsilatError(getOrderPaymentDetailsResponse.error?.message ||
-                "Payment details API call failed", getOrderPaymentDetailsResponse.error?.code ||
-                "PAYMENT_DETAILS_API_FAILED");
-        if (!getOrderPaymentDetailsResponse.data)
-            throw new TapsilatError("Payment details response data is missing", "PAYMENT_DETAILS_DATA_MISSING");
-        return getOrderPaymentDetailsResponse.data;
+        try {
+            const getOrderPaymentDetailsResponse = await this.httpClient.get(`/order/${referenceId}/payment-details`);
+            return handleResponse(getOrderPaymentDetailsResponse, "Order payment details by id");
+        }
+        catch (error) {
+            return handleError(error, "order payment details by id");
+        }
+    }
+    /**
+     * Retrieves the order callback via GET request.
+     * Based on `order_callback` from the Python SDK.
+     */
+    async orderCallback(id) {
+        if (!isNonEmptyString(id))
+            throw new TapsilatValidationError("ID is required and must be a non-empty string");
+        try {
+            const response = await this.httpClient.get(`/orders/${id}/callback`);
+            return handleResponse(response, "Order callback");
+        }
+        catch (error) {
+            return handleError(error, "order callback");
+        }
+    }
+    /**
+     * Updates payment options for an order.
+     * Based on `update_payment_options` from the Python SDK.
+     */
+    async updatePaymentOptions(request) {
+        try {
+            const response = await this.httpClient.patch("/order/payment-options", request);
+            return handleResponse(response, "Update payment options");
+        }
+        catch (error) {
+            return handleError(error, "update payment options");
+        }
+    }
+    /**
+     * Splits order item payment.
+     * Based on `split_order_item_payment` from the Python SDK.
+     */
+    async splitOrderItemPayment(request) {
+        try {
+            const response = await this.httpClient.post("/order/split", request);
+            return handleResponse(response, "Split order item payment");
+        }
+        catch (error) {
+            return handleError(error, "split order item payment");
+        }
+    }
+    /**
+     * Queries vpos for an order.
+     * Based on `order_vpos_query` from the Python SDK.
+     */
+    async orderVposQuery(id) {
+        if (!isNonEmptyString(id))
+            throw new TapsilatValidationError("ID is required and must be a non-empty string");
+        try {
+            const response = await this.httpClient.get(`/orders/${id}/vpos-query`);
+            return handleResponse(response, "Order vpos query");
+        }
+        catch (error) {
+            return handleError(error, "order vpos query");
+        }
     }
     // ORDER LOOKUP BY CONVERSATION ID
     // Summary: Find order using conversation ID instead of reference ID
@@ -1887,13 +2158,18 @@ class TapsilatSDK {
         if (!isNonEmptyString(conversationId)) {
             throw new TapsilatValidationError("Order conversationId is required and must be a non-empty string", { provided: conversationId });
         }
-        const getOrderByConversationIdResponse = await this.httpClient.get(`/order/conversation/${conversationId}`);
-        if (!getOrderByConversationIdResponse.success)
-            throw new TapsilatError(getOrderByConversationIdResponse.error?.message ||
-                "Order retrieval by conversation ID failed", getOrderByConversationIdResponse.error?.code || "ORDER_RETRIEVAL_FAILED");
-        if (!getOrderByConversationIdResponse.data)
-            throw new TapsilatError("Order response data is missing", "ORDER_DATA_MISSING");
-        return getOrderByConversationIdResponse.data;
+        try {
+            const getOrderByConversationIdResponse = await this.httpClient.get(`/order/conversation/${conversationId}`);
+            if (!getOrderByConversationIdResponse.success)
+                throw new TapsilatError(getOrderByConversationIdResponse.error?.message ||
+                    "Order retrieval by conversation ID failed", getOrderByConversationIdResponse.error?.code || "ORDER_RETRIEVAL_FAILED");
+            if (!getOrderByConversationIdResponse.data)
+                throw new TapsilatError("Order response data is missing", "ORDER_DATA_MISSING");
+            return getOrderByConversationIdResponse.data;
+        }
+        catch (error) {
+            return handleError(error, "order retrieval by conversation ID");
+        }
     }
     // ORDER TRANSACTION HISTORY
     // Summary: Retrieve transaction history for an order
@@ -1915,14 +2191,19 @@ class TapsilatSDK {
         if (!isNonEmptyString(referenceId)) {
             throw new TapsilatValidationError("Order referenceId is required and must be a non-empty string", { provided: referenceId });
         }
-        const getOrderTransactionsResponse = await this.httpClient.get(`/order/${referenceId}/transactions`);
-        if (!getOrderTransactionsResponse.success)
-            throw new TapsilatError(getOrderTransactionsResponse.error?.message ||
-                "Order transactions retrieval failed", getOrderTransactionsResponse.error?.code ||
-                "TRANSACTIONS_RETRIEVAL_FAILED");
-        if (!getOrderTransactionsResponse.data)
-            throw new TapsilatError("Order transactions response data is missing", "TRANSACTIONS_DATA_MISSING");
-        return getOrderTransactionsResponse.data;
+        try {
+            const getOrderTransactionsResponse = await this.httpClient.get(`/order/${referenceId}/transactions`);
+            if (!getOrderTransactionsResponse.success)
+                throw new TapsilatError(getOrderTransactionsResponse.error?.message ||
+                    "Order transactions retrieval failed", getOrderTransactionsResponse.error?.code ||
+                    "TRANSACTIONS_RETRIEVAL_FAILED");
+            if (!getOrderTransactionsResponse.data)
+                throw new TapsilatError("Order transactions response data is missing", "TRANSACTIONS_DATA_MISSING");
+            return getOrderTransactionsResponse.data;
+        }
+        catch (error) {
+            return handleError(error, "order transactions retrieval");
+        }
     }
     // ORDER SUBMERCHANT LISTING
     // Summary: Retrieve paginated list of submerchants for orders
@@ -1939,16 +2220,15 @@ class TapsilatSDK {
      * @throws {TapsilatError} When API returns an error response
      */
     async getOrderSubmerchants(params = {}) {
-        const getOrderSubmerchantsResponse = await this.httpClient.get("/order/submerchants", {
-            params: params,
-        });
-        if (!getOrderSubmerchantsResponse.success)
-            throw new TapsilatError(getOrderSubmerchantsResponse.error?.message ||
-                "Order submerchants retrieval failed", getOrderSubmerchantsResponse.error?.code ||
-                "SUBMERCHANTS_RETRIEVAL_FAILED");
-        if (!getOrderSubmerchantsResponse.data)
-            throw new TapsilatError("Order submerchants response data is missing", "SUBMERCHANTS_DATA_MISSING");
-        return getOrderSubmerchantsResponse.data;
+        try {
+            const getOrderSubmerchantsResponse = await this.httpClient.get("/order/submerchants", {
+                params: params,
+            });
+            return handleResponse(getOrderSubmerchantsResponse, "Order submerchants retrieval");
+        }
+        catch (error) {
+            return handleError(error, "order submerchants retrieval");
+        }
     }
     // ORDER CHECKOUT URL RETRIEVAL
     // Summary: Retrieve checkout URL for existing order
@@ -2008,19 +2288,22 @@ class TapsilatSDK {
      * @throws {TapsilatError} When API health check fails or returns invalid data
      */
     async healthCheck() {
-        // We use the direct /health endpoint which returns plain string "OK"
-        const healthCheckResponse = await this.httpClient.get("/health");
-        if (!healthCheckResponse.success) {
-            throw new TapsilatError(healthCheckResponse.error?.message || "Health check failed", healthCheckResponse.error?.code || "HEALTH_CHECK_FAILED");
+        try {
+            // We use the direct /health endpoint which returns plain string "OK"
+            const healthCheckResponse = await this.httpClient.get("/health");
+            const healthData = handleResponse(healthCheckResponse, "Health check");
+            // The API returns "OK" string, verify consistency
+            if (healthData !== "OK") {
+                throw new TapsilatError(`Unexpected health check response: ${healthData}`, "HEALTH_CHECK_INVALID_RESPONSE");
+            }
+            return {
+                status: "UP",
+                timestamp: new Date().toISOString(),
+            };
         }
-        // The API returns "OK" string, verify consistency
-        if (healthCheckResponse.data !== "OK") {
-            throw new TapsilatError(`Unexpected health check response: ${healthCheckResponse.data}`, "HEALTH_CHECK_INVALID_RESPONSE");
+        catch (error) {
+            return handleError(error, "health check");
         }
-        return {
-            status: "UP",
-            timestamp: new Date().toISOString(),
-        };
     }
     // CONFIGURATION MANAGEMENT
     // Summary: Access to the configuration manager for advanced configuration management
@@ -2313,8 +2596,8 @@ class TapsilatSDK {
             payload.conversation_id = conversationId;
         }
         try {
-            const response = await this.httpClient.post("/order/manual-callback", payload);
-            return handleResponse(response, "Order manual callback");
+            const orderManualCallbackResponse = await this.httpClient.post("/order/callback", payload);
+            return handleResponse(orderManualCallbackResponse, "Order manual callback");
         }
         catch (error) {
             return handleError(error, "order manual callback");
@@ -2328,11 +2611,12 @@ class TapsilatSDK {
             throw new TapsilatValidationError("Related Reference ID is required and must be a non-empty string");
         }
         try {
-            const response = await this.httpClient.post("/order/related-update", {
+            const payload = {
                 reference_id: referenceId,
                 related_reference_id: relatedReferenceId,
-            });
-            return handleResponse(response, "Order related update");
+            };
+            const orderRelatedUpdateResponse = await this.httpClient.patch("/order/releated", payload);
+            return handleResponse(orderRelatedUpdateResponse, "Order related update");
         }
         catch (error) {
             return handleError(error, "order related update");
@@ -2340,8 +2624,8 @@ class TapsilatSDK {
     }
     async getOrganizationSettings() {
         try {
-            const response = await this.httpClient.get("/organization/settings");
-            return handleResponse(response, "Get organization settings");
+            const organizationSettingsResponse = await this.httpClient.get("/organization/settings");
+            return handleResponse(organizationSettingsResponse, "Get organization settings");
         }
         catch (error) {
             return handleError(error, "get organization settings");
@@ -2352,20 +2636,280 @@ class TapsilatSDK {
             throw new TapsilatValidationError("Term Reference ID is required and must be a non-empty string");
         }
         try {
-            const response = await this.httpClient.get(`/order/term`, {
+            const orderTermResponse = await this.httpClient.get(`/order/term`, {
                 params: { term_reference_id: termReferenceId },
             });
-            return handleResponse(response, "Get order term");
+            return handleResponse(orderTermResponse, "Get order term");
         }
         catch (error) {
             return handleError(error, "get order term");
         }
     }
     // SUBSCRIPTION METHODS
+    /**
+     * Add a new item to an existing order basket
+     */
+    async addBasketItem(request) {
+        try {
+            const addBasketItemResponse = await this.httpClient.post("/order/basket-item", request);
+            return handleResponse(addBasketItemResponse, "Add basket item");
+        }
+        catch (error) {
+            return handleError(error, "add basket item");
+        }
+    }
+    /**
+     * Remove an item from an existing order basket
+     */
+    async removeBasketItem(request) {
+        try {
+            const removeBasketItemResponse = await this.httpClient.delete("/order/basket-item", request);
+            return handleResponse(removeBasketItemResponse, "Remove basket item");
+        }
+        catch (error) {
+            return handleError(error, "remove basket item");
+        }
+    }
+    /**
+     * Update an existing item in an order basket
+     */
+    async updateBasketItem(request) {
+        try {
+            const updateBasketItemResponse = await this.httpClient.patch("/order/basket-item", request);
+            return handleResponse(updateBasketItemResponse, "Update basket item");
+        }
+        catch (error) {
+            return handleError(error, "update basket item");
+        }
+    }
+    /**
+     * Retrieve organization callback (webhook) settings
+     */
+    async getOrganizationCallback() {
+        try {
+            const organizationCallbackResponse = await this.httpClient.get("/organization/callback");
+            return handleResponse(organizationCallbackResponse, "Get organization callback");
+        }
+        catch (error) {
+            return handleError(error, "get organization callback");
+        }
+    }
+    /**
+     * Update organization callback (webhook) settings
+     */
+    async updateOrganizationCallback(request) {
+        try {
+            const organizationCallbackResponse = await this.httpClient.patch("/organization/callback", request);
+            return handleResponse(organizationCallbackResponse, "Update organization callback");
+        }
+        catch (error) {
+            return handleError(error, "update organization callback");
+        }
+    }
+    /**
+     * Create a new business entity within the organization
+     */
+    async createOrganizationBusiness(request) {
+        try {
+            const organizationBusinessResponse = await this.httpClient.post("/organization/business/create", request);
+            return handleResponse(organizationBusinessResponse, "Create organization business");
+        }
+        catch (error) {
+            return handleError(error, "create organization business");
+        }
+    }
+    /**
+     * Retrieve supported currencies for the organization
+     */
+    async getOrganizationCurrencies() {
+        try {
+            const organizationCurrenciesResponse = await this.httpClient.get("/organization/currencies");
+            return handleResponse(organizationCurrenciesResponse, "Get organization currencies");
+        }
+        catch (error) {
+            return handleError(error, "get organization currencies");
+        }
+    }
+    /**
+     * Retrieves organization currency presets.
+     * Based on `get_organization_currency_presets` from Python SDK.
+     */
+    async getOrganizationCurrencyPresets() {
+        try {
+            const response = await this.httpClient.get("/organization/currency-presets");
+            return handleResponse(response, "Get organization currency presets");
+        }
+        catch (error) {
+            return handleError(error, "get organization currency presets");
+        }
+    }
+    /**
+     * Retrieves organization suborganization details.
+     * Based on `get_organization_suborganization_details` from Python SDK.
+     */
+    async getOrganizationSuborganizationDetails(id) {
+        if (!isNonEmptyString(id))
+            throw new TapsilatValidationError("ID is required and must be a non-empty string");
+        try {
+            const response = await this.httpClient.get(`/organization/suborganizations/${id}`);
+            return handleResponse(response, "Get suborganization details");
+        }
+        catch (error) {
+            return handleError(error, "get suborganization details");
+        }
+    }
+    /**
+     * Retrieves organization suborganization submerchants.
+     * Based on `get_organization_suborganization_submerchants` from Python SDK.
+     */
+    async getOrganizationSuborganizationSubmerchants(id) {
+        if (!isNonEmptyString(id))
+            throw new TapsilatValidationError("ID is required and must be a non-empty string");
+        try {
+            const response = await this.httpClient.get(`/organization/suborganizations/${id}/submerchant`);
+            return handleResponse(response, "Get suborganization submerchants");
+        }
+        catch (error) {
+            return handleError(error, "get suborganization submerchants");
+        }
+    }
+    /**
+     * Retrieve limit information for a specific organization user
+     */
+    async getOrganizationLimitUser(request) {
+        try {
+            const organizationLimitUserResponse = await this.httpClient.get("/organization/limit/user", { params: request });
+            return handleResponse(organizationLimitUserResponse, "Get organization user limit");
+        }
+        catch (error) {
+            return handleError(error, "get organization user limit");
+        }
+    }
+    /**
+     * Set limit for a specific organization user
+     */
+    async setOrganizationLimitUser(request) {
+        try {
+            const organizationLimitUserResponse = await this.httpClient.post("/organization/limit/user", request);
+            return handleResponse(organizationLimitUserResponse, "Set organization user limit");
+        }
+        catch (error) {
+            return handleError(error, "set organization user limit");
+        }
+    }
+    /**
+     * Retrieve organization overall limits
+     */
+    async getOrganizationLimits() {
+        try {
+            const organizationLimitsResponse = await this.httpClient.get("/organization/limits");
+            return handleResponse(organizationLimitsResponse, "Get organization limits");
+        }
+        catch (error) {
+            return handleError(error, "get organization limits");
+        }
+    }
+    /**
+     * Retrieve meta information for the organization
+     */
+    async getOrganizationMeta(name) {
+        if (!isNonEmptyString(name)) {
+            throw new TapsilatValidationError("Meta name is required and must be a non-empty string");
+        }
+        try {
+            const organizationMetaResponse = await this.httpClient.get(`/organization/meta/${name}`);
+            return handleResponse(organizationMetaResponse, "Get organization meta");
+        }
+        catch (error) {
+            return handleError(error, "get organization meta");
+        }
+    }
+    /**
+     * Retrieve supported scopes for the organization
+     */
+    async getOrganizationScopes() {
+        try {
+            const organizationScopesResponse = await this.httpClient.get("/organization/scopes");
+            return handleResponse(organizationScopesResponse, "Get organization scopes");
+        }
+        catch (error) {
+            return handleError(error, "get organization scopes");
+        }
+    }
+    /**
+     * Retrieve list of sub-organizations
+     */
+    async getOrganizationSuborganizations(params = {}) {
+        if (params.page !== undefined) {
+            if (!isInteger(params.page) || params.page < 1) {
+                throw new TapsilatValidationError("Suborganization page must be a positive integer", { provided: params.page });
+            }
+        }
+        if (params.per_page !== undefined) {
+            if (!isInteger(params.per_page) || params.per_page < 1) {
+                throw new TapsilatValidationError("Suborganization per_page must be a positive integer", { provided: params.per_page });
+            }
+        }
+        try {
+            const organizationSuborganizationsResponse = await this.httpClient.get("/organization/suborganizations", { params: params });
+            return handleResponse(organizationSuborganizationsResponse, "Get organization suborganizations");
+        }
+        catch (error) {
+            return handleError(error, "get organization suborganizations");
+        }
+    }
+    /**
+     * Create a new user within the organization
+     */
+    async createOrganizationUser(request) {
+        try {
+            const organizationUserResponse = await this.httpClient.post("/organization/user/create", request);
+            return handleResponse(organizationUserResponse, "Create organization user");
+        }
+        catch (error) {
+            return handleError(error, "create organization user");
+        }
+    }
+    /**
+     * Verify an organization user
+     */
+    async verifyOrganizationUser(request) {
+        try {
+            const organizationUserVerifyResponse = await this.httpClient.post("/organization/user/verify", request);
+            return handleResponse(organizationUserVerifyResponse, "Verify organization user");
+        }
+        catch (error) {
+            return handleError(error, "verify organization user");
+        }
+    }
+    /**
+     * Verify an organization user via mobile
+     */
+    async verifyOrganizationUserMobile(request) {
+        try {
+            const organizationUserMobileVerifyResponse = await this.httpClient.post("/organization/user/verify-mobile", request);
+            return handleResponse(organizationUserMobileVerifyResponse, "Verify organization user mobile");
+        }
+        catch (error) {
+            return handleError(error, "verify organization user mobile");
+        }
+    }
+    /**
+     * List virtual POS terminals for the organization
+     */
+    async listOrganizationVpos(request) {
+        try {
+            const organizationVposResponse = await this.httpClient.post("/organization/list-vpos", request);
+            return handleResponse(organizationVposResponse, "List organization VPOs");
+        }
+        catch (error) {
+            return handleError(error, "list organization VPOs");
+        }
+    }
     async createSubscription(request) {
         try {
-            const response = await this.httpClient.post("/subscription/create", request);
-            return handleResponse(response, "Create subscription");
+            const subcriptionCreateResponse = await this.httpClient.post("/subscription/create", request);
+            return handleResponse(subcriptionCreateResponse, "Create subscription");
         }
         catch (error) {
             return handleError(error, "create subscription");
@@ -2373,8 +2917,8 @@ class TapsilatSDK {
     }
     async getSubscription(request) {
         try {
-            const response = await this.httpClient.post("/subscription", request);
-            const data = handleResponse(response, "Get subscription");
+            const subscriptionDetailResponse = await this.httpClient.post("/subscription", request);
+            const data = handleResponse(subscriptionDetailResponse, "Get subscription");
             if (data.orders) {
                 data.orders.forEach((order) => {
                     if (order.payment_url && !order.payment_url.startsWith("http")) {
@@ -2390,8 +2934,8 @@ class TapsilatSDK {
     }
     async listSubscriptions(params = {}) {
         try {
-            const response = await this.httpClient.get("/subscription/list", { params });
-            return handleResponse(response, "List subscriptions");
+            const listSubscriptionsResponse = await this.httpClient.get("/subscription/list", { params });
+            return handleResponse(listSubscriptionsResponse, "List subscriptions");
         }
         catch (error) {
             return handleError(error, "list subscriptions");
@@ -2399,8 +2943,8 @@ class TapsilatSDK {
     }
     async cancelSubscription(request) {
         try {
-            const response = await this.httpClient.post("/subscription/cancel", request);
-            return handleResponse(response, "Cancel subscription");
+            const subscriptionCancelResponse = await this.httpClient.post("/subscription/cancel", request);
+            return handleResponse(subscriptionCancelResponse, "Cancel subscription");
         }
         catch (error) {
             return handleError(error, "cancel subscription");
@@ -2408,8 +2952,8 @@ class TapsilatSDK {
     }
     async redirectSubscription(request) {
         try {
-            const response = await this.httpClient.post("/subscription/redirect", request);
-            const data = handleResponse(response, "Redirect subscription");
+            const subscriptionRedirectResponse = await this.httpClient.post("/subscription/redirect", request);
+            const data = handleResponse(subscriptionRedirectResponse, "Redirect subscription");
             if (data.url) {
                 // Extract subscription ID from the signed URL to create a clean link
                 // api returns: /token/subscription/{id}
@@ -2430,6 +2974,24 @@ class TapsilatSDK {
     }
 }
 
+/**
+ * @module Types
+ * @description Tapsilat SDK type definitions, interfaces, and API data structures
+ */
+/**
+ * @category Organization
+ * @summary Organization business types
+ * @enum {number}
+ */
+exports.BusinessType = void 0;
+(function (BusinessType) {
+    BusinessType[BusinessType["INDIVIDUAL"] = 0] = "INDIVIDUAL";
+    BusinessType[BusinessType["CORPORATE"] = 1] = "CORPORATE";
+    BusinessType[BusinessType["NON_PROFIT"] = 2] = "NON_PROFIT";
+    BusinessType[BusinessType["GOVERNMENT"] = 3] = "GOVERNMENT";
+    BusinessType[BusinessType["UNKNOWN"] = 4] = "UNKNOWN";
+})(exports.BusinessType || (exports.BusinessType = {}));
+
 exports.ConfigManager = ConfigManager;
 exports.TapsilatAuthenticationError = TapsilatAuthenticationError;
 exports.TapsilatError = TapsilatError;