@tapsilat/tapsilat-js 1.0.7 → 2025.11.19

package/dist/index.js

@@ -260,7 +260,7 @@ class InterceptorManager {
                 try {
                     return await interceptor(error, request);
                 }
-                catch (interceptorError) {
+                catch {
                     // Continue to next interceptor if this one fails
                     continue;
                 }
@@ -367,15 +367,10 @@ class HttpClient {
             }
         }
         // Execute error interceptors as last resort
-        try {
-            return await this.interceptors.executeErrorInterceptors(lastError, {
-                url: interceptedUrl,
-                options: interceptedOptions,
-            });
-        }
-        catch (finalError) {
-            throw finalError;
-        }
+        return this.interceptors.executeErrorInterceptors(lastError, {
+            url: interceptedUrl,
+            options: interceptedOptions,
+        });
     }
     /**
      * @category HTTP Client Internals
@@ -436,7 +431,7 @@ class HttpClient {
                 responseData = await response.text();
             }
         }
-        catch (parseError) {
+        catch {
             throw new TapsilatError("Failed to parse response body", "PARSE_ERROR");
         }
         // Handle successful responses
@@ -478,11 +473,12 @@ class HttpClient {
                 return new TapsilatValidationError(errorMessage || "Invalid request data");
             case 422:
                 return new TapsilatValidationError(errorMessage || "Validation failed", this.extractValidationDetails(data));
-            case 429:
+            case 429: {
                 const rateLimitInfo = this.extractRateLimitInfo(response);
                 return new TapsilatRateLimitError(errorMessage || "Rate limit exceeded", rateLimitInfo.resetTime
                     ? Math.floor((rateLimitInfo.resetTime.getTime() - Date.now()) / 1000)
                     : undefined);
+            }
             case 404:
                 return new TapsilatError(errorMessage || "Resource not found", "NOT_FOUND");
             case 500:
@@ -1019,6 +1015,186 @@ function sanitizeMetadata(metadata) {
     }
     return sanitized;
 }
+// GSM NUMBER VALIDATION
+// Summary: Validates and cleans Turkish GSM phone numbers
+// Description: Supports multiple phone number formats and automatically cleans formatting
+/**
+ * Validates and cleans GSM phone numbers
+ *
+ * @summary Validates and cleans Turkish GSM phone numbers
+ * @description
+ * Supports multiple phone number formats including international (+90), national (0),
+ * and local formats. Automatically removes formatting characters and validates
+ * against Turkish mobile number patterns.
+ *
+ * Supported formats:
+ * - +90 5XX XXX XX XX
+ * - 0 5XX XXX XX XX
+ * - 5XX XXX XX XX
+ * - Various formatting with spaces, dashes, parentheses
+ *
+ * @param {string | number} gsmNumber - GSM number to validate and clean
+ * @returns {GsmValidationResult} Validation result with cleaned number or error
+ */
+function validateGsmNumber(gsmNumber) {
+    const originalNumber = String(gsmNumber);
+    // Basic validation
+    if (!originalNumber || typeof originalNumber !== 'string') {
+        return {
+            isValid: false,
+            error: "GSM number must be a non-empty string",
+            originalNumber
+        };
+    }
+    // Clean the number - remove all non-digit characters
+    let cleanedNumber = originalNumber.replace(/[^\d]/g, '');
+    // Handle different formats
+    if (cleanedNumber.startsWith('90')) {
+        // International format +90 or 90
+        cleanedNumber = cleanedNumber.substring(2);
+    }
+    else if (cleanedNumber.startsWith('0')) {
+        // National format 0
+        cleanedNumber = cleanedNumber.substring(1);
+    }
+    // Validate Turkish mobile number pattern
+    // Turkish mobile numbers start with 5 and are 10 digits total
+    const turkishMobilePattern = /^5[0-9]{9}$/;
+    if (!turkishMobilePattern.test(cleanedNumber)) {
+        return {
+            isValid: false,
+            error: "Invalid Turkish GSM number format. Must be 10 digits starting with 5",
+            originalNumber
+        };
+    }
+    // Additional validation for known Turkish mobile operators
+    const operatorPrefixes = ['50', '51', '52', '53', '54', '55', '56', '57', '58', '59'];
+    const prefix = cleanedNumber.substring(0, 2);
+    if (!operatorPrefixes.includes(prefix)) {
+        return {
+            isValid: false,
+            error: "Invalid Turkish mobile operator prefix",
+            originalNumber
+        };
+    }
+    return {
+        isValid: true,
+        cleanedNumber: `+90${cleanedNumber}`,
+        originalNumber
+    };
+}
+// INSTALLMENTS VALIDATION
+// Summary: Validates installment values and converts to standardized format
+// Description: Handles various input formats and validates against business rules
+/**
+ * Validates installment values and converts to standardized format
+ *
+ * @summary Validates installment values and converts to standardized format
+ * @description
+ * Handles various input formats (string, number, array) and validates against
+ * business rules. Converts single installment values to arrays and validates
+ * that installment numbers are within acceptable ranges.
+ *
+ * Supported inputs:
+ * - Single number: 3 -> [3]
+ * - Comma-separated string: "1,3,6" -> [1,3,6]
+ * - Array of numbers: [1,3,6,12] -> [1,3,6,12]
+ * - Empty/null values default to [1]
+ *
+ * @param {string | number | number[]} installments - Installment values to validate
+ * @returns {InstallmentsValidationResult} Validation result with standardized array
+ */
+function validateInstallments(installments) {
+    const originalInput = installments;
+    // Handle empty/null/undefined - default to single installment
+    if (!installments || installments === '' || installments === null || installments === undefined || installments === 0) {
+        return {
+            isValid: true,
+            validatedInstallments: [1],
+            originalInput: String(originalInput)
+        };
+    }
+    let installmentArray = [];
+    try {
+        if (typeof installments === 'number') {
+            // Single number
+            installmentArray = [installments];
+        }
+        else if (typeof installments === 'string') {
+            // Handle comma-separated string
+            if (installments.includes(',')) {
+                installmentArray = installments
+                    .split(',')
+                    .map(item => {
+                    const num = parseInt(item.trim(), 10);
+                    if (isNaN(num)) {
+                        throw new Error(`Invalid installment value: ${item.trim()}`);
+                    }
+                    return num;
+                });
+            }
+            else {
+                // Single string number
+                const num = parseInt(installments.trim(), 10);
+                if (isNaN(num)) {
+                    throw new Error(`Invalid installment value: ${installments}`);
+                }
+                installmentArray = [num];
+            }
+        }
+        else if (Array.isArray(installments)) {
+            // Array of numbers
+            installmentArray = installments.map((item, index) => {
+                if (typeof item !== 'number' || isNaN(item)) {
+                    throw new Error(`Invalid installment value at index ${index}: ${item}`);
+                }
+                return item;
+            });
+        }
+        else {
+            return {
+                isValid: false,
+                validatedInstallments: [1],
+                error: "Installments must be a number, string, or array of numbers",
+                originalInput: String(originalInput)
+            };
+        }
+        // Validate installment values
+        for (const installment of installmentArray) {
+            if (!Number.isInteger(installment) || installment < 1) {
+                return {
+                    isValid: false,
+                    validatedInstallments: [1],
+                    error: `Installment values must be positive integers, got: ${installment}`,
+                    originalInput: String(originalInput)
+                };
+            }
+            if (installment > 36) {
+                return {
+                    isValid: false,
+                    validatedInstallments: [1],
+                    error: `Installment values cannot exceed 36, got: ${installment}`,
+                    originalInput: String(originalInput)
+                };
+            }
+        }
+        // Remove duplicates and sort
+        const uniqueInstallments = [...new Set(installmentArray)].sort((a, b) => a - b);
+        return {
+            isValid: true,
+            validatedInstallments: uniqueInstallments,
+            originalInput: String(originalInput)
+        };
+    }
+    catch (error) {
+        return {
+            isValid: false,
+            validatedInstallments: [1],
+            error: error instanceof Error ? error.message : "Unknown validation error",
+            originalInput: String(originalInput)
+        };
+    }
+}
 
 /**
  * @category Configuration
@@ -1215,7 +1391,7 @@ class TapsilatSDK {
      *
      * @param {TapsilatConfig} config - SDK configuration options
      * @param {string} config.bearerToken - API authentication token (required)
-     * @param {string} [config.baseURL='https://api.tapsilat.com/v1'] - API base URL
+     * @param {string} [config.baseURL='https://panel.tapsilat.dev/v1'] - API base URL
      * @param {number} [config.timeout=30000] - Request timeout in milliseconds
      * @param {number} [config.maxRetries=3] - Maximum number of retry attempts
      * @param {number} [config.retryDelay=1000] - Delay between retries in milliseconds
@@ -1236,71 +1412,65 @@ class TapsilatSDK {
     /**
      * Creates a new order and returns a checkout URL
      *
-     * @summary Initiates a new payment order with buyer information and generates checkout URL
+     * @summary Initiates a new payment order with comprehensive order details
      * @description
      * Creates a new payment order in the Tapsilat system with the provided order details.
      * This method performs comprehensive validation of all input parameters, creates the order
-     * on the payment platform, and returns a checkout URL that customers can use to complete
-     * their payment. The method supports multiple currencies, locales, and comprehensive
-     * buyer information for compliance and fraud prevention.
+     * on the payment platform, and returns order identifiers including reference_id and order_id.
+     * The method supports multiple currencies, locales, payment options, basket items,
+     * and comprehensive buyer information for compliance and fraud prevention.
      *
-     * The returned checkout URL is valid for a limited time (typically 24 hours) and should
-     * be presented to the customer immediately. The order status can be tracked using the
-     * returned reference ID through the getOrderStatus method.
+     * The returned order_id and reference_id can be used to track order status through
+     * the getOrderStatus method.
      *
      * @param {OrderCreateRequest} orderRequest - Complete order information
      * @param {number} orderRequest.amount - Payment amount (must be positive, max 2 decimal places)
+     * @param {number} [orderRequest.tax_amount] - Tax amount included in total
      * @param {Currency} orderRequest.currency - Payment currency ('TRY', 'USD', 'EUR', 'GBP')
      * @param {Locale} orderRequest.locale - Display language ('tr' for Turkish, 'en' for English)
+     * @param {boolean} [orderRequest.three_d_force] - Force 3D Secure authentication
+     * @param {Address} [orderRequest.shipping_address] - Shipping address for delivery
+     * @param {BasketItem[]} orderRequest.basket_items - Array of items in the order
+     * @param {BillingAddress} orderRequest.billing_address - Billing address with tax information
      * @param {Buyer} orderRequest.buyer - Customer information for payment processing
-     * @param {string} orderRequest.buyer.name - Customer's first name (required)
-     * @param {string} orderRequest.buyer.surname - Customer's last name (required)
-     * @param {string} orderRequest.buyer.email - Customer's email address (required, validated)
-     * @param {string} [orderRequest.buyer.phone] - Customer's phone number
-     * @param {string} [orderRequest.buyer.identityNumber] - National ID or tax number
-     * @param {Address} [orderRequest.buyer.shippingAddress] - Shipping address for physical goods
-     * @param {Address} [orderRequest.buyer.billingAddress] - Billing address for invoicing
-     * @param {string} [orderRequest.description] - Order description for customer reference
-     * @param {string} [orderRequest.callbackUrl] - URL to redirect after payment completion
-     * @param {string} [orderRequest.conversationId] - Custom tracking ID for your system
+     * @param {string} [orderRequest.conversation_id] - Custom tracking ID for your system
+     * @param {boolean} [orderRequest.partial_payment] - Enable partial payment
+     * @param {boolean} [orderRequest.payment_methods] - Enable payment method selection
+     * @param {PaymentOption[]} [orderRequest.payment_options] - Available payment options
+     * @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
      *
      * @returns {Promise<OrderCreateResponse>} Promise resolving to order creation response
-     * @returns {string} OrderCreateResponse.referenceId - Unique order identifier for tracking
-     * @returns {string} OrderCreateResponse.conversationId - Echo of provided conversation ID
-     * @returns {string} OrderCreateResponse.checkoutUrl - Payment page URL for customer
-     * @returns {string} OrderCreateResponse.status - Initial order status (typically 'CREATED')
-     * @returns {string} [OrderCreateResponse.qrCodeUrl] - QR code URL for mobile payments
+     * @returns {string} OrderCreateResponse.order_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
+     * @returns {string} [OrderCreateResponse.status] - Initial order status
+     * @returns {string} [OrderCreateResponse.qr_code_url] - QR code URL for mobile payments
      *
      * @throws {TapsilatValidationError} When input validation fails:
      *   - Amount is not positive or has more than 2 decimal places
      *   - Currency is not supported
      *   - Buyer information is incomplete or invalid
-     *   - Email format is invalid
+     *   - Basket items are missing or invalid
+     *   - Billing address is missing
      *   - Required fields are missing
-     * @throws {TapsilatNetworkError} When network request fails:
-     *   - Connection timeout
-     *   - DNS resolution failure
-     *   - Network connectivity issues
-     * @throws {TapsilatError} When API returns business logic errors:
-     *   - Insufficient merchant balance
-     *   - Currency not enabled for merchant
-     *   - Buyer blocked due to fraud detection
-     *   - Rate limiting exceeded
+     * @throws {TapsilatNetworkError} When network request fails
+     * @throws {TapsilatError} When API returns business logic errors
      */
     async createOrder(orderRequest) {
-        // Validate the order request directly
-        // Check if request is null/undefined
+        // Validate the order request
         if (!orderRequest) {
             throw new TapsilatValidationError("Order request cannot be null or undefined");
         }
-        // Validate amount - check if positive
+        // Validate amount
         if (!isPositiveNumber(orderRequest.amount)) {
             throw new TapsilatValidationError("Amount must be a positive number", {
                 provided: orderRequest.amount,
             });
         }
-        // Validate amount - check decimal places
         if (!hasValidDecimalPlaces(orderRequest.amount)) {
             throw new TapsilatValidationError("Amount must have maximum 2 decimal places", { provided: orderRequest.amount });
         }
@@ -1308,6 +1478,10 @@ class TapsilatSDK {
         if (!isNonEmptyString(orderRequest.currency)) {
             throw new TapsilatValidationError("Currency is required and must be a non-empty string", { provided: orderRequest.currency });
         }
+        // Validate locale
+        if (!isNonEmptyString(orderRequest.locale)) {
+            throw new TapsilatValidationError("Locale is required and must be a non-empty string", { provided: orderRequest.locale });
+        }
         // Validate buyer information
         if (!orderRequest.buyer) {
             throw new TapsilatValidationError("Buyer information is required");
@@ -1319,14 +1493,20 @@ class TapsilatSDK {
         if (!isNonEmptyString(buyer.surname)) {
             throw new TapsilatValidationError("Buyer surname is required and must be a non-empty string", { provided: buyer.surname });
         }
-        // Validate buyer email - check if provided
         if (!isNonEmptyString(buyer.email)) {
             throw new TapsilatValidationError("Buyer email is required and must be a non-empty string", { provided: buyer.email });
         }
-        // Validate buyer email - check format
         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);
@@ -1766,6 +1946,260 @@ class TapsilatSDK {
     getConfigManager() {
         return this.configManager;
     }
+    // PAYMENT TERM MANAGEMENT
+    // Summary: Create, update, delete, and manage payment terms for orders
+    // Description: Full lifecycle management of payment terms including installments and refunds
+    /**
+     * Creates a new payment term for an existing order
+     *
+     * @summary Create payment term for installment or partial payment
+     * @description
+     * Creates a new payment term for an existing order, enabling installment payments
+     * or partial payment collection. Payment terms allow splitting order amounts
+     * across multiple payments with specific due dates and requirements.
+     *
+     * @param {OrderPaymentTermCreateDTO} termData - Payment term creation data
+     * @param {string} termData.order_id - Reference ID of the existing order
+     * @param {string} termData.term_reference_id - Unique identifier for this payment term
+     * @param {number} termData.amount - Amount for this payment term
+     * @param {string} termData.due_date - Due date for this payment (ISO 8601 format)
+     * @param {number} termData.term_sequence - Sequence number for this term
+     * @param {boolean} termData.required - Whether this payment term is required
+     * @param {string} termData.status - Initial status of the payment term
+     * @param {string} [termData.data] - Additional metadata for the term
+     * @param {string} [termData.paid_date] - Date when payment was completed
+     *
+     * @returns {Promise<PaymentTermResponse>} Promise resolving to created payment term details
+     * @throws {TapsilatValidationError} When input validation fails
+     * @throws {TapsilatError} When API returns an error response
+     */
+    async createOrderTerm(termData) {
+        // Validate required fields
+        if (!isNonEmptyString(termData.order_id)) {
+            throw new TapsilatValidationError("Order ID is required and must be a non-empty string", { provided: termData.order_id });
+        }
+        if (!isNonEmptyString(termData.term_reference_id)) {
+            throw new TapsilatValidationError("Term reference ID is required and must be a non-empty string", { provided: termData.term_reference_id });
+        }
+        if (!isPositiveNumber(termData.amount)) {
+            throw new TapsilatValidationError("Amount must be a positive number", {
+                provided: termData.amount,
+            });
+        }
+        if (!hasValidDecimalPlaces(termData.amount)) {
+            throw new TapsilatValidationError("Amount must have maximum 2 decimal places", { provided: termData.amount });
+        }
+        if (!isNonEmptyString(termData.due_date)) {
+            throw new TapsilatValidationError("Due date is required and must be a non-empty string", { provided: termData.due_date });
+        }
+        if (!isInteger(termData.term_sequence)) {
+            throw new TapsilatValidationError("Term sequence must be an integer", {
+                provided: termData.term_sequence,
+            });
+        }
+        if (typeof termData.required !== "boolean") {
+            throw new TapsilatValidationError("Required field must be a boolean", {
+                provided: termData.required,
+            });
+        }
+        if (!isNonEmptyString(termData.status)) {
+            throw new TapsilatValidationError("Status is required and must be a non-empty string", { provided: termData.status });
+        }
+        try {
+            const createTermResponse = await this.httpClient.post("/order/term/create", termData);
+            return handleResponse(createTermResponse, "Payment term creation");
+        }
+        catch (error) {
+            return handleError(error, "payment term creation");
+        }
+    }
+    /**
+     * Updates an existing payment term
+     *
+     * @summary Update payment term details
+     * @description
+     * Updates an existing payment term with new information such as amount,
+     * due date, status, or other metadata. This allows for flexible management
+     * of installment payments and payment schedules.
+     *
+     * @param {OrderPaymentTermUpdateDTO} updateData - Payment term update data
+     * @param {string} updateData.term_reference_id - Reference ID of the term to update
+     * @param {number} [updateData.amount] - New amount for the payment term
+     * @param {string} [updateData.due_date] - New due date (ISO 8601 format)
+     * @param {string} [updateData.paid_date] - Date when payment was completed
+     * @param {boolean} [updateData.required] - Whether this payment term is required
+     * @param {string} [updateData.status] - New status of the payment term
+     * @param {number} [updateData.term_sequence] - New sequence number
+     *
+     * @returns {Promise<PaymentTermResponse>} Promise resolving to updated payment term details
+     * @throws {TapsilatValidationError} When input validation fails
+     * @throws {TapsilatError} When API returns an error response
+     */
+    async updateOrderTerm(updateData) {
+        // Validate required fields
+        if (!isNonEmptyString(updateData.term_reference_id)) {
+            throw new TapsilatValidationError("Term reference ID is required and must be a non-empty string", { provided: updateData.term_reference_id });
+        }
+        // Validate optional amount if provided
+        if (updateData.amount !== undefined) {
+            if (!isPositiveNumber(updateData.amount)) {
+                throw new TapsilatValidationError("Amount must be a positive number", {
+                    provided: updateData.amount,
+                });
+            }
+            if (!hasValidDecimalPlaces(updateData.amount)) {
+                throw new TapsilatValidationError("Amount must have maximum 2 decimal places", { provided: updateData.amount });
+            }
+        }
+        // Validate optional term sequence if provided
+        if (updateData.term_sequence !== undefined) {
+            if (!isInteger(updateData.term_sequence)) {
+                throw new TapsilatValidationError("Term sequence must be an integer", {
+                    provided: updateData.term_sequence,
+                });
+            }
+        }
+        // Validate optional required field if provided
+        if (updateData.required !== undefined &&
+            typeof updateData.required !== "boolean") {
+            throw new TapsilatValidationError("Required field must be a boolean", {
+                provided: updateData.required,
+            });
+        }
+        try {
+            const updateTermResponse = await this.httpClient.post("/order/term/update", updateData);
+            return handleResponse(updateTermResponse, "Payment term update");
+        }
+        catch (error) {
+            return handleError(error, "payment term update");
+        }
+    }
+    /**
+     * Deletes a payment term
+     *
+     * @summary Delete payment term
+     * @description
+     * Permanently deletes a payment term from an order. This action cannot be undone.
+     * Only unpaid payment terms can be deleted.
+     *
+     * @param {PaymentTermDeleteRequest} deleteData - Payment term deletion data
+     * @param {string} deleteData.term_reference_id - Reference ID of the term to delete
+     *
+     * @returns {Promise<PaymentTermResponse>} Promise resolving to deleted payment term details
+     * @throws {TapsilatValidationError} When input validation fails
+     * @throws {TapsilatError} When API returns an error response
+     */
+    async deleteOrderTerm(deleteData) {
+        // Validate required fields
+        if (!isNonEmptyString(deleteData.term_reference_id)) {
+            throw new TapsilatValidationError("Term reference ID is required and must be a non-empty string", { provided: deleteData.term_reference_id });
+        }
+        try {
+            const deleteTermResponse = await this.httpClient.post("/order/term/delete", deleteData);
+            return handleResponse(deleteTermResponse, "Payment term deletion");
+        }
+        catch (error) {
+            return handleError(error, "payment term deletion");
+        }
+    }
+    /**
+     * Refunds a specific payment term
+     *
+     * @summary Refund payment term
+     * @description
+     * Processes a refund for a specific payment term. This allows partial refunds
+     * at the payment term level rather than the entire order level.
+     *
+     * @param {OrderTermRefundRequest} refundData - Payment term refund data
+     * @param {string} refundData.term_id - ID of the term to refund
+     * @param {number} refundData.amount - Amount to refund
+     * @param {string} [refundData.reference_id] - Optional reference ID
+     * @param {string} [refundData.term_payment_id] - Optional term payment ID
+     *
+     * @returns {Promise<PaymentTermRefundResponse>} Promise resolving to refund details
+     * @throws {TapsilatValidationError} When input validation fails
+     * @throws {TapsilatError} When API returns an error response
+     */
+    async refundOrderTerm(refundData) {
+        // Validate required fields
+        if (!isNonEmptyString(refundData.term_id)) {
+            throw new TapsilatValidationError("Term ID is required and must be a non-empty string", { provided: refundData.term_id });
+        }
+        if (!isPositiveNumber(refundData.amount)) {
+            throw new TapsilatValidationError("Amount must be a positive number", {
+                provided: refundData.amount,
+            });
+        }
+        if (!hasValidDecimalPlaces(refundData.amount)) {
+            throw new TapsilatValidationError("Amount must have maximum 2 decimal places", { provided: refundData.amount });
+        }
+        try {
+            const refundTermResponse = await this.httpClient.post("/order/term/refund", refundData);
+            return handleResponse(refundTermResponse, "Payment term refund");
+        }
+        catch (error) {
+            return handleError(error, "payment term refund");
+        }
+    }
+    /**
+     * Terminates a payment term
+     *
+     * @summary Terminate payment term
+     * @description
+     * Terminates an active payment term, preventing further payments.
+     * This is useful for canceling installment plans or payment schedules.
+     *
+     * @param {PaymentTermTerminateRequest} terminateData - Payment term termination data
+     * @param {string} terminateData.term_reference_id - Reference ID of the term to terminate
+     * @param {string} [terminateData.reason] - Optional reason for termination
+     *
+     * @returns {Promise<PaymentTermResponse>} Promise resolving to terminated term details
+     * @throws {TapsilatValidationError} When input validation fails
+     * @throws {TapsilatError} When API returns an error response
+     */
+    async terminateOrderTerm(terminateData) {
+        // Validate required fields
+        if (!isNonEmptyString(terminateData.term_reference_id)) {
+            throw new TapsilatValidationError("Term reference ID is required and must be a non-empty string", { provided: terminateData.term_reference_id });
+        }
+        try {
+            const terminateTermResponse = await this.httpClient.post("/order/term/terminate", terminateData);
+            return handleResponse(terminateTermResponse, "Payment term termination");
+        }
+        catch (error) {
+            return handleError(error, "payment term termination");
+        }
+    }
+    /**
+     * Terminates an entire order
+     *
+     * @summary Terminate order
+     * @description
+     * Terminates an entire order, canceling all associated payment terms and
+     * preventing any further payment processing. This is a more comprehensive
+     * action than canceling individual payment terms.
+     *
+     * @param {OrderTerminateRequest} terminateData - Order termination data
+     * @param {string} terminateData.reference_id - Reference ID of the order to terminate
+     * @param {string} [terminateData.reason] - Optional reason for termination
+     *
+     * @returns {Promise<OrderTerminateResponse>} Promise resolving to terminated order details
+     * @throws {TapsilatValidationError} When input validation fails
+     * @throws {TapsilatError} When API returns an error response
+     */
+    async terminateOrder(terminateData) {
+        // Validate required fields
+        if (!isNonEmptyString(terminateData.reference_id)) {
+            throw new TapsilatValidationError("Reference ID is required and must be a non-empty string", { provided: terminateData.reference_id });
+        }
+        try {
+            const terminateOrderResponse = await this.httpClient.post("/order/terminate", terminateData);
+            return handleResponse(terminateOrderResponse, "Order termination");
+        }
+        catch (error) {
+            return handleError(error, "order termination");
+        }
+    }
 }
 
 exports.ConfigManager = ConfigManager;
@@ -1780,5 +2214,7 @@ exports.isValidPaymentMethod = isValidPaymentMethod;
 exports.isValidUrl = isValidUrl;
 exports.sanitizeMetadata = sanitizeMetadata;
 exports.validateEmail = validateEmail;
+exports.validateGsmNumber = validateGsmNumber;
+exports.validateInstallments = validateInstallments;
 exports.validatePaymentRequest = validatePaymentRequest;
 //# sourceMappingURL=index.js.map