@tapsilat/tapsilat-js 1.0.2

package/dist/index.js

@@ -0,0 +1,1131 @@
+'use strict';
+
+class TapsilatError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.name = 'TapsilatError';
+        this.code = code;
+        this.details = details;
+        // Maintain proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, TapsilatError);
+        }
+    }
+    static fromAPIError(apiError) {
+        return new TapsilatError(apiError.message, apiError.code, apiError.details);
+    }
+}
+class TapsilatNetworkError extends TapsilatError {
+    statusCode;
+    constructor(message, code, statusCode, details) {
+        super(message, code, details);
+        this.name = 'TapsilatNetworkError';
+        this.statusCode = statusCode;
+    }
+}
+class TapsilatValidationError extends TapsilatError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', details);
+        this.name = 'TapsilatValidationError';
+    }
+}
+class TapsilatAuthenticationError extends TapsilatError {
+    constructor(message = 'Authentication failed') {
+        super(message, 'AUTHENTICATION_ERROR');
+        this.name = 'TapsilatAuthenticationError';
+    }
+}
+class TapsilatRateLimitError extends TapsilatError {
+    retryAfter;
+    constructor(message = 'Rate limit exceeded', retryAfter) {
+        super(message, 'RATE_LIMIT_ERROR');
+        this.name = 'TapsilatRateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+
+class InterceptorManager {
+    requestInterceptors = [];
+    responseInterceptors = [];
+    errorInterceptors = [];
+    // Request interceptors
+    addRequestInterceptor(interceptor) {
+        this.requestInterceptors.push(interceptor);
+        return this.requestInterceptors.length - 1;
+    }
+    removeRequestInterceptor(id) {
+        if (this.requestInterceptors[id]) {
+            delete this.requestInterceptors[id];
+        }
+    }
+    async executeRequestInterceptors(url, options) {
+        let currentUrl = url;
+        let currentOptions = options;
+        for (const interceptor of this.requestInterceptors) {
+            if (interceptor) {
+                const result = await interceptor(currentUrl, currentOptions);
+                currentUrl = result.url;
+                currentOptions = result.options;
+            }
+        }
+        return { url: currentUrl, options: currentOptions };
+    }
+    // Response interceptors
+    addResponseInterceptor(interceptor) {
+        this.responseInterceptors.push(interceptor);
+        return this.responseInterceptors.length - 1;
+    }
+    removeResponseInterceptor(id) {
+        if (this.responseInterceptors[id]) {
+            delete this.responseInterceptors[id];
+        }
+    }
+    async executeResponseInterceptors(response, request) {
+        let currentResponse = response;
+        for (const interceptor of this.responseInterceptors) {
+            if (interceptor) {
+                currentResponse = await interceptor(currentResponse, request);
+            }
+        }
+        return currentResponse;
+    }
+    // Error interceptors
+    addErrorInterceptor(interceptor) {
+        this.errorInterceptors.push(interceptor);
+        return this.errorInterceptors.length - 1;
+    }
+    removeErrorInterceptor(id) {
+        if (this.errorInterceptors[id]) {
+            delete this.errorInterceptors[id];
+        }
+    }
+    async executeErrorInterceptors(error, request) {
+        for (const interceptor of this.errorInterceptors) {
+            if (interceptor) {
+                try {
+                    return await interceptor(error, request);
+                }
+                catch (interceptorError) {
+                    // Continue to next interceptor if this one fails
+                    continue;
+                }
+            }
+        }
+        // If no interceptor handled the error, re-throw
+        throw error;
+    }
+    // Clear all interceptors
+    clear() {
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+    }
+}
+
+/**
+ * HTTP Client for making API requests with comprehensive error handling,
+ * retry logic, and request/response interceptors
+ *
+ * @example
+ * ```typescript
+ * const client = new HttpClient({
+ *   apiKey: 'your-api-key',
+ *   baseURL: 'https://api.example.com/v1'
+ * });
+ *
+ * const data = await client.get<UserResponse>('/users/123');
+ * ```
+ */
+class HttpClient {
+    config;
+    interceptors = new InterceptorManager();
+    constructor(config) {
+        this.config = config;
+    }
+    async get(url, config) {
+        return this.request("GET", url, undefined, config);
+    }
+    async post(url, body, config) {
+        return this.request("POST", url, body, config);
+    }
+    async put(url, body, config) {
+        return this.request("PUT", url, body, config);
+    }
+    async patch(url, body, config) {
+        return this.request("PATCH", url, body, config);
+    }
+    async delete(url, config) {
+        return this.request("DELETE", url, undefined, config);
+    }
+    /**
+     * Core request method with comprehensive error handling and retry logic
+     *
+     * @param method - HTTP method to use
+     * @param url - Request URL (relative to baseURL)
+     * @param body - Request body data
+     * @param config - Additional request configuration
+     * @returns Promise resolving to API response
+     */
+    async request(method, url, body, config) {
+        const fullUrl = this.buildUrl(url, config?.baseURL, config?.params);
+        const requestOptions = await this.buildRequestOptions(method, body, config);
+        const maxRetries = config?.retries ?? this.config.maxRetries ?? 3;
+        // Execute request interceptors
+        const { url: interceptedUrl, options: interceptedOptions } = await this.interceptors.executeRequestInterceptors(fullUrl, requestOptions);
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await this.makeRequest(interceptedUrl, interceptedOptions, config?.timeout);
+                // Execute response interceptors
+                const interceptedResponse = await this.interceptors.executeResponseInterceptors(response, {
+                    url: interceptedUrl,
+                    options: interceptedOptions,
+                });
+                return interceptedResponse;
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on certain error types
+                if (this.shouldNotRetry(lastError)) {
+                    break;
+                }
+                // Don't retry on the last attempt
+                if (attempt === maxRetries) {
+                    break;
+                }
+                // Wait before retry with exponential backoff
+                await this.delay(this.calculateRetryDelay(attempt));
+            }
+        }
+        // Execute error interceptors as last resort
+        try {
+            return await this.interceptors.executeErrorInterceptors(lastError, {
+                url: interceptedUrl,
+                options: interceptedOptions,
+            });
+        }
+        catch (finalError) {
+            throw finalError;
+        }
+    }
+    /**
+     * Makes the actual HTTP request with timeout handling
+     */
+    async makeRequest(url, options, timeout) {
+        const controller = new AbortController();
+        const timeoutId = timeout
+            ? setTimeout(() => controller.abort(), timeout)
+            : null;
+        try {
+            const requestOptions = {
+                ...options,
+                signal: controller.signal,
+            };
+            const response = await fetch(url, requestOptions);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            return await this.processResponse(response);
+        }
+        catch (error) {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            if (error instanceof Error) {
+                if (error.name === "AbortError") {
+                    throw new TapsilatNetworkError("Request timeout", "TIMEOUT");
+                }
+                throw new TapsilatNetworkError(`Network request failed: ${error.message}`, "NETWORK_ERROR");
+            }
+            throw new TapsilatNetworkError("Unknown network error", "UNKNOWN");
+        }
+    }
+    /**
+     * Processes the fetch response and converts to APIResponse format
+     */
+    async processResponse(response) {
+        const contentType = response.headers.get("content-type");
+        const isJson = contentType?.includes("application/json");
+        let responseData;
+        try {
+            if (isJson) {
+                responseData = await response.json();
+            }
+            else {
+                responseData = await response.text();
+            }
+        }
+        catch (parseError) {
+            throw new TapsilatError("Failed to parse response body", "PARSE_ERROR");
+        }
+        // Handle successful responses
+        if (response.ok) {
+            return {
+                success: true,
+                data: responseData,
+            };
+        }
+        // Handle error responses
+        const error = this.createErrorFromResponse(response, responseData);
+        return {
+            success: false,
+            error: {
+                message: error.message,
+                code: error.code,
+                details: error.details,
+            },
+        };
+    }
+    /**
+     * Creates appropriate error based on response status and data
+     */
+    createErrorFromResponse(response, data) {
+        const status = response.status;
+        const errorMessage = this.extractErrorMessage(data);
+        switch (status) {
+            case 401:
+                return new TapsilatAuthenticationError(errorMessage || "Authentication failed - invalid API key");
+            case 403:
+                return new TapsilatAuthenticationError(errorMessage || "Access forbidden - insufficient permissions");
+            case 400:
+                return new TapsilatValidationError(errorMessage || "Invalid request data");
+            case 422:
+                return new TapsilatValidationError(errorMessage || "Validation failed", this.extractValidationDetails(data));
+            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:
+                return new TapsilatError(errorMessage || "Internal server error", "INTERNAL_ERROR");
+            case 502:
+            case 503:
+            case 504:
+                return new TapsilatNetworkError(errorMessage || "Service temporarily unavailable", "SERVICE_UNAVAILABLE", status);
+            default:
+                return new TapsilatError(errorMessage || `HTTP ${status} error`, "HTTP_ERROR");
+        }
+    }
+    /**
+     * Extracts error message from response data
+     */
+    extractErrorMessage(data) {
+        if (typeof data === "string") {
+            return data;
+        }
+        if (data && typeof data === "object") {
+            const obj = data;
+            return (obj.message || obj.error || obj.detail);
+        }
+        return undefined;
+    }
+    /**
+     * Extracts validation details from error response
+     */
+    extractValidationDetails(data) {
+        if (data && typeof data === "object") {
+            const obj = data;
+            return obj.errors;
+        }
+        return undefined;
+    }
+    /**
+     * Extracts rate limit information from response headers
+     */
+    extractRateLimitInfo(response) {
+        const limit = response.headers.get("x-ratelimit-limit");
+        const remaining = response.headers.get("x-ratelimit-remaining");
+        const reset = response.headers.get("x-ratelimit-reset");
+        return {
+            limit: limit ? parseInt(limit, 10) : undefined,
+            remaining: remaining ? parseInt(remaining, 10) : undefined,
+            resetTime: reset ? new Date(parseInt(reset, 10) * 1000) : undefined,
+        };
+    }
+    /**
+     * Builds the complete URL for the request
+     */
+    buildUrl(url, customBaseURL, params) {
+        const baseURL = customBaseURL || this.config.baseURL || "https://api.tapsilat.com/v1";
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+            return url;
+        }
+        const base = baseURL.replace(/\/+$/, "");
+        const path = url.replace(/^\/+/, "");
+        let fullUrl = `${base}/${path}`;
+        // Add query parameters if provided
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null && value !== "") {
+                    searchParams.append(key, String(value));
+                }
+            }
+            const queryString = searchParams.toString();
+            if (queryString) {
+                fullUrl += `?${queryString}`;
+            }
+        }
+        return fullUrl;
+    }
+    /**
+     * Builds RequestInit options for the fetch request
+     */
+    async buildRequestOptions(method, body, config) {
+        const headers = new Headers({
+            "User-Agent": `TapsilatSDK/1.0.0`,
+            Authorization: `Bearer ${this.config.bearerToken}`,
+            Accept: "application/json",
+            ...config?.headers,
+        });
+        // Set content type for requests with body
+        if (body && method !== "GET" && method !== "DELETE") {
+            if (!(body instanceof FormData)) {
+                headers.set("Content-Type", "application/json");
+            }
+        }
+        const options = {
+            method,
+            headers,
+            ...config,
+        };
+        // Add body for non-GET/DELETE requests
+        if (body && method !== "GET" && method !== "DELETE") {
+            if (body instanceof FormData) {
+                options.body = body;
+            }
+            else if (typeof body === "string") {
+                options.body = body;
+            }
+            else {
+                options.body = JSON.stringify(body);
+            }
+        }
+        return options;
+    }
+    /**
+     * Determines if an error should prevent retrying
+     */
+    shouldNotRetry(error) {
+        // Don't retry authentication, validation, or client errors
+        return (error instanceof TapsilatAuthenticationError ||
+            error instanceof TapsilatValidationError ||
+            (error instanceof TapsilatError && error.code === "NOT_FOUND"));
+    }
+    /**
+     * Calculates retry delay with exponential backoff
+     */
+    calculateRetryDelay(attempt) {
+        const baseDelay = 1000; // 1 second
+        const maxDelay = 30000; // 30 seconds
+        const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+        // Add jitter to prevent thundering herd
+        return delay + Math.random() * 1000;
+    }
+    /**
+     * Utility method to create delay
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // Interceptor management methods
+    /**
+     * Gets the interceptor manager for advanced request/response handling
+     *
+     * @returns InterceptorManager instance
+     */
+    getInterceptors() {
+        return this.interceptors;
+    }
+    /**
+     * Adds a request interceptor
+     *
+     * @param interceptor - Request interceptor function
+     * @returns Interceptor ID for removal
+     */
+    addRequestInterceptor(interceptor) {
+        return this.interceptors.addRequestInterceptor(interceptor);
+    }
+    /**
+     * Adds a response interceptor
+     *
+     * @param interceptor - Response interceptor function
+     * @returns Interceptor ID for removal
+     */
+    addResponseInterceptor(interceptor) {
+        return this.interceptors.addResponseInterceptor(interceptor);
+    }
+    /**
+     * Adds an error interceptor
+     *
+     * @param interceptor - Error interceptor function
+     * @returns Interceptor ID for removal
+     */
+    addErrorInterceptor(interceptor) {
+        return this.interceptors.addErrorInterceptor(interceptor);
+    }
+}
+
+// Type Guards
+/**
+ * Type guard to check if a value is a valid PaymentMethod
+ */
+function isPaymentMethod(value) {
+    return (typeof value === "string" &&
+        ["credit_card", "debit_card", "bank_transfer", "digital_wallet"].includes(value));
+}
+/**
+ * Type guard to check if a value is a valid Currency
+ */
+function isCurrency(value) {
+    return (typeof value === "string" && ["TRY", "USD", "EUR", "GBP"].includes(value));
+}
+/**
+ * Type guard to check if a value is a non-empty string
+ */
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/**
+ * Type guard to check if a value is a positive number
+ */
+function isPositiveNumber(value) {
+    return (typeof value === "number" && value > 0 && !isNaN(value) && isFinite(value));
+}
+/**
+ * Type guard to check if amount has max 2 decimal places
+ */
+function hasValidDecimalPlaces(amount) {
+    const decimalPlaces = (amount.toString().split(".")[1] || "").length;
+    return decimalPlaces <= 2;
+}
+// Validation Functions
+/**
+ * Validates Bearer token format and strength
+ *
+ * @param bearerToken - Bearer token to validate
+ * @throws {TapsilatValidationError} When Bearer token is invalid
+ */
+function validateBearerToken(bearerToken) {
+    if (!isNonEmptyString(bearerToken)) {
+        throw new TapsilatValidationError("Bearer token must be a non-empty string");
+    }
+    if (bearerToken.length < 10) {
+        throw new TapsilatValidationError("Bearer token must be at least 10 characters long");
+    }
+    // Karakter kontrolü (opsiyonel, isterseniz ek kurallar koyabilirsiniz)
+    if (!/^[a-zA-Z0-9._-]+$/.test(bearerToken)) {
+        throw new TapsilatValidationError("Bearer token contains invalid characters");
+    }
+}
+/**
+ * Validates payment request data comprehensively
+ *
+ * @param request - Payment request to validate
+ * @throws {TapsilatValidationError} When any field is invalid
+ */
+function validatePaymentRequest(request) {
+    if (!request || typeof request !== "object") {
+        throw new TapsilatValidationError("Payment request must be an object");
+    }
+    const req = request;
+    // Amount validation
+    if (!isPositiveNumber(req.amount)) {
+        throw new TapsilatValidationError("Amount must be a positive number");
+    }
+    if (!hasValidDecimalPlaces(req.amount)) {
+        throw new TapsilatValidationError("Amount cannot have more than 2 decimal places");
+    }
+    // Currency validation
+    if (!isCurrency(req.currency)) {
+        throw new TapsilatValidationError(`Currency must be one of: ${["TRY", "USD", "EUR", "GBP"].join(", ")}`);
+    }
+    // Payment method validation
+    if (!isPaymentMethod(req.paymentMethod)) {
+        throw new TapsilatValidationError(`Payment method must be one of: ${[
+            "credit_card",
+            "debit_card",
+            "bank_transfer",
+            "digital_wallet",
+        ].join(", ")}`);
+    }
+    // Optional field validations
+    if (req.description !== undefined && !isNonEmptyString(req.description)) {
+        throw new TapsilatValidationError("Description must be a non-empty string when provided");
+    }
+    if (req.returnUrl !== undefined && !isValidUrl(req.returnUrl)) {
+        throw new TapsilatValidationError("Return URL must be a valid HTTP/HTTPS URL when provided");
+    }
+    if (req.cancelUrl !== undefined && !isValidUrl(req.cancelUrl)) {
+        throw new TapsilatValidationError("Cancel URL must be a valid HTTP/HTTPS URL when provided");
+    }
+    if (req.metadata !== undefined &&
+        (typeof req.metadata !== "object" || req.metadata === null)) {
+        throw new TapsilatValidationError("Metadata must be an object when provided");
+    }
+}
+/**
+ * Validates email format using robust regex
+ *
+ * @param email - Email address to validate
+ * @returns True if email format is valid
+ */
+function validateEmail(email) {
+    if (!isNonEmptyString(email)) {
+        return false;
+    }
+    // More comprehensive email regex
+    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    return emailRegex.test(email);
+}
+/**
+ * @deprecated Use isCurrency type guard instead
+ */
+function isValidCurrency(currency) {
+    return isCurrency(currency);
+}
+/**
+ * @deprecated Use isPaymentMethod type guard instead
+ */
+function isValidPaymentMethod(paymentMethod) {
+    return isPaymentMethod(paymentMethod);
+}
+/**
+ * Validates URL format and protocol
+ *
+ * @param url - URL to validate
+ * @returns True if URL is valid HTTP/HTTPS
+ */
+function isValidUrl(url) {
+    if (!isNonEmptyString(url)) {
+        return false;
+    }
+    try {
+        const urlObj = new URL(url);
+        return urlObj.protocol === "http:" || urlObj.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sanitizes metadata by removing sensitive keys and cleaning values
+ *
+ * @param metadata - Raw metadata object
+ * @returns Sanitized metadata object
+ */
+function sanitizeMetadata(metadata) {
+    const sensitiveKeys = new Set([
+        "password",
+        "secret",
+        "token",
+        "apikey",
+        "api_key",
+        "auth",
+        "authorization",
+        "cookie",
+        "session",
+        "bearertoken",
+    ]);
+    const sanitized = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        // Skip sensitive keys (case-insensitive)
+        if (sensitiveKeys.has(key.toLowerCase())) {
+            continue;
+        }
+        // Clean and validate values
+        let cleanValue = value;
+        if (typeof value === "string") {
+            cleanValue = value.trim();
+            // Skip empty strings
+            if (cleanValue === "") {
+                continue;
+            }
+        }
+        else if (value === null || value === undefined) {
+            // Skip null/undefined values
+            continue;
+        }
+        else if (typeof value === "object") {
+            // Convert objects to string representation
+            cleanValue = "[object Object]";
+        }
+        sanitized[key] = cleanValue;
+    }
+    return sanitized;
+}
+
+/**
+ * Main SDK class for Tapsilat payment operations
+ *
+ * @example
+ * ```typescript
+ * const tapsilat = new TapsilatSDK({
+ *   bearerToken: 'your-bearer-token',
+ *   baseURL: 'https://api.tapsilat.com/v1'
+ * });
+ *
+ * const payment = await tapsilat.createPayment({
+ *   amount: 100.50,
+ *   currency: 'TRY',
+ *   paymentMethod: 'credit_card'
+ * });
+ * ```
+ */
+class TapsilatSDK {
+    httpClient;
+    config;
+    /**
+     * Creates a new TapsilatSDK instance
+     *
+     * @param config - SDK configuration options
+     * @throws {TapsilatValidationError} When Bearer token is invalid
+     */
+    constructor(config) {
+        validateBearerToken(config.bearerToken);
+        this.config = config;
+        this.httpClient = new HttpClient(config);
+    }
+    // Order Operations
+    /**
+     * Creates a new order and returns a checkout URL.
+     *
+     * @param orderRequest - The order details including amount, currency, and buyer information
+     * @returns Promise resolving to the created order response including reference ID and checkout URL
+     * @throws {TapsilatValidationError} When order request data is invalid
+     * @throws {TapsilatNetworkError} When API request fails due to network issues
+     * @throws {TapsilatError} When API returns an error response
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const orderResponse = await tapsilat.createOrder({
+     *     amount: 100.50,
+     *     currency: 'TRY',
+     *     locale: 'en',
+     *     buyer: {
+     *       name: 'John',
+     *       surname: 'Doe',
+     *       email: 'john.doe@example.com'
+     *     }
+     *   });
+     *   console.log(`Checkout URL: ${orderResponse.checkoutUrl}`);
+     * } catch (error) {
+     *   console.error(`Order creation failed: ${error.message}`);
+     * }
+     * ```
+     */
+    async createOrder(orderRequest) {
+        // Validate the order request
+        this.validateOrderRequest(orderRequest);
+        try {
+            // Make the API request
+            const response = await this.httpClient.post("/order/create", orderRequest);
+            // Use our generic response handler
+            return this.handleResponse(response, "Order creation");
+        }
+        catch (error) {
+            // Use our generic error handler
+            this.handleError(error, "order creation");
+        }
+    }
+    /**
+     * Validates an order request object
+     * @private
+     */
+    validateOrderRequest(orderRequest) {
+        // Check if request is null/undefined
+        if (!orderRequest) {
+            throw new TapsilatValidationError("Order request cannot be null or undefined");
+        }
+        // Validate amount
+        if (!isPositiveNumber(orderRequest.amount) ||
+            !hasValidDecimalPlaces(orderRequest.amount)) {
+            throw new TapsilatValidationError("Amount must be a positive number with maximum 2 decimal places", { provided: orderRequest.amount });
+        }
+        // Validate currency
+        if (!isNonEmptyString(orderRequest.currency)) {
+            throw new TapsilatValidationError("Currency is required and must be a non-empty string", { provided: orderRequest.currency });
+        }
+        // Validate buyer information
+        if (!orderRequest.buyer) {
+            throw new TapsilatValidationError("Buyer information is required");
+        }
+        const { buyer } = orderRequest;
+        if (!isNonEmptyString(buyer.name)) {
+            throw new TapsilatValidationError("Buyer name is required and must be a non-empty string", { provided: buyer.name });
+        }
+        if (!isNonEmptyString(buyer.surname)) {
+            throw new TapsilatValidationError("Buyer surname is required and must be a non-empty string", { provided: buyer.surname });
+        }
+        if (!isNonEmptyString(buyer.email) || !this.isValidEmail(buyer.email)) {
+            throw new TapsilatValidationError("Buyer email is required and must be a valid email address", { provided: buyer.email });
+        }
+    }
+    /**
+     * Basic email validation
+     * @private
+     */
+    isValidEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+    /**
+     * Generic response handler - consistent way to handle API responses across SDK methods
+     * @private
+     *
+     * @param response - The API response to process
+     * @param errorContext - Descriptive context for error messages
+     * @returns The data from a successful response
+     * @throws {TapsilatError} On any response error
+     */
+    handleResponse(response, errorContext) {
+        if (!response.success || !response.data) {
+            // Convert API errors to domain-specific errors
+            if (response.error) {
+                throw TapsilatError.fromAPIError(response.error);
+            }
+            throw new TapsilatError(`${errorContext} failed with no error details`, "UNKNOWN_ERROR");
+        }
+        return response.data;
+    }
+    /**
+     * Generic error handler - consistent way to handle errors across SDK methods
+     * @private
+     *
+     * @param error - The caught error to process
+     * @param errorContext - Descriptive context for error messages
+     * @throws {TapsilatError} Always throws an appropriate error type
+     */
+    handleError(error, errorContext) {
+        // Rethrow TapsilatErrors as-is
+        if (error instanceof TapsilatError) {
+            throw error;
+        }
+        // Convert generic errors to TapsilatNetworkError
+        throw new TapsilatNetworkError(error instanceof Error
+            ? error.message
+            : `Unknown error during ${errorContext}`, "NETWORK_ERROR");
+    }
+    /**
+     * Gets an order by reference ID.
+     *
+     * @param referenceId - The unique reference ID of the order
+     * @returns Promise resolving to the complete order details
+     * @throws {TapsilatValidationError} When referenceId is invalid
+     * @throws {TapsilatNetworkError} When API request fails due to network issues
+     * @throws {TapsilatError} When API returns an error response
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const order = await tapsilat.getOrder("ord_123456789");
+     *   console.log(`Order amount: ${order.amount} ${order.currency}`);
+     * } catch (error) {
+     *   console.error(`Failed to get order: ${error.message}`);
+     * }
+     * ```
+     */
+    async getOrder(referenceId) {
+        // Validate input
+        if (!isNonEmptyString(referenceId)) {
+            throw new TapsilatValidationError("Order referenceId is required and must be a non-empty string", { provided: referenceId });
+        }
+        try {
+            // Make the API request
+            const response = await this.httpClient.get(`/order/${referenceId}`);
+            // Use our generic response handler
+            return this.handleResponse(response, "Order retrieval");
+        }
+        catch (error) {
+            // Use our generic error handler
+            this.handleError(error, "order retrieval");
+        }
+    }
+    /**
+     * Lists orders with pagination support.
+     *
+     * @param params - Optional pagination parameters (page number and items per page)
+     * @returns Promise resolving to paginated list of orders
+     * @throws {TapsilatNetworkError} When API request fails due to network issues
+     * @throws {TapsilatError} When API returns an error response
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   // Get the second page with 20 items per page
+     *   const orderList = await tapsilat.getOrders({ page: 2, per_page: 20 });
+     *   console.log(`Total orders: ${orderList.total}`);
+     *   orderList.rows.forEach(order => {
+     *     console.log(`Order ${order.referenceId}: ${order.amount} ${order.currency}`);
+     *   });
+     * } catch (error) {
+     *   console.error(`Failed to list orders: ${error.message}`);
+     * }
+     * ```
+     */
+    async getOrders(params = {}) {
+        try {
+            // Validate pagination parameters if provided
+            if (params.page !== undefined &&
+                (!Number.isInteger(params.page) || params.page < 1)) {
+                throw new TapsilatValidationError("Page number must be a positive integer", { provided: params.page });
+            }
+            if (params.per_page !== undefined &&
+                (!Number.isInteger(params.per_page) || params.per_page < 1)) {
+                throw new TapsilatValidationError("Items per page must be a positive integer", { provided: params.per_page });
+            }
+            // Make the API request
+            const response = await this.httpClient.get("/order/list", { params: params });
+            // Use our generic response handler
+            return this.handleResponse(response, "Order listing");
+        }
+        catch (error) {
+            // Use our generic error handler
+            this.handleError(error, "order listing");
+        }
+    }
+    /**
+     * Cancels an order by reference_id.
+     */
+    async cancelOrder(referenceId) {
+        if (!referenceId) {
+            throw new Error("Order referenceId is required for cancellation");
+        }
+        const response = await this.httpClient.post("/order/cancel", {
+            reference_id: referenceId,
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || "Order cancellation failed");
+        }
+        return response.data;
+    }
+    /**
+     * Gets the status of an order by reference ID.
+     *
+     * @param referenceId - The unique reference ID of the order
+     * @returns Promise resolving to the current order status, including status code and last update time
+     * @throws {TapsilatValidationError} When referenceId is invalid
+     * @throws {TapsilatNetworkError} When API request fails due to network issues
+     * @throws {TapsilatError} When API returns an error response
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const orderStatus = await tapsilat.getOrderStatus("ord_123456789");
+     *   console.log(`Order status: ${orderStatus.status}`);
+     * } catch (error) {
+     *   if (error instanceof TapsilatValidationError) {
+     *     console.error("Invalid reference ID format");
+     *   } else if (error instanceof TapsilatError) {
+     *     console.error(`API error: ${error.message}`);
+     *   }
+     * }
+     * ```
+     */
+    async getOrderStatus(referenceId) {
+        // Validate input using proper validation
+        if (!isNonEmptyString(referenceId)) {
+            throw new TapsilatValidationError("Order referenceId is required and must be a non-empty string", { provided: referenceId });
+        }
+        try {
+            // Make the API request
+            const response = await this.httpClient.get(`/order/${referenceId}/status`);
+            // Use our generic response handler
+            return this.handleResponse(response, "Order status retrieval");
+        }
+        catch (error) {
+            // Use our generic error handler
+            this.handleError(error, "order status retrieval");
+        }
+    }
+    /**
+     * Partially refunds an order.
+     * Based on `refund_order` from the Python SDK.
+     *
+     * @param refundData - The refund details, including referenceId and amount.
+     * @returns Promise resolving to the refund transaction details.
+     */
+    async refundOrder(refundData) {
+        const response = await this.httpClient.post("/order/refund", refundData);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || "Order refund failed");
+        }
+        return response.data;
+    }
+    /**
+     * Fully refunds an order by its reference ID.
+     * Based on `refund_all_order` from the Python SDK.
+     *
+     * @param referenceId - The unique identifier of the order to fully refund.
+     * @returns Promise resolving to the refund transaction details.
+     */
+    async refundAllOrder(referenceId) {
+        const response = await this.httpClient.post("/order/refund-all", { reference_id: referenceId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || "Full order refund failed");
+        }
+        return response.data;
+    }
+    /**
+     * Retrieves the payment details for an order.
+     * Based on `get_order_payment_details` from the Python SDK.
+     *
+     * @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.
+     */
+    async getOrderPaymentDetails(referenceId, conversationId) {
+        if (conversationId) {
+            // If conversation_id is provided, use POST to /order/payment-details
+            const response = await this.httpClient.post("/order/payment-details", { conversation_id: conversationId, reference_id: referenceId });
+            if (!response.success || !response.data) {
+                throw new Error(response.error?.message || "Failed to get payment details");
+            }
+            return response.data;
+        }
+        else {
+            // If no conversation_id, use GET to /order/{reference_id}/payment-details
+            const response = await this.httpClient.get(`/order/${referenceId}/payment-details`);
+            if (!response.success || !response.data) {
+                throw new Error(response.error?.message || "Failed to get payment details");
+            }
+            return response.data;
+        }
+    }
+    /**
+     * Gets an order by conversation_id.
+     * Based on `get_order_by_conversation_id` from the Python SDK.
+     */
+    async getOrderByConversationId(conversationId) {
+        if (!conversationId) {
+            throw new Error("Order conversationId is required");
+        }
+        const response = await this.httpClient.get(`/order/conversation/${conversationId}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || "Order retrieval by conversation ID failed");
+        }
+        return response.data;
+    }
+    /**
+     * Gets order transactions by reference_id.
+     * Based on `get_order_transactions` from the Python SDK.
+     */
+    async getOrderTransactions(referenceId) {
+        if (!referenceId) {
+            throw new Error("Order referenceId is required");
+        }
+        const response = await this.httpClient.get(`/order/${referenceId}/transactions`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || "Order transactions retrieval failed");
+        }
+        return response.data;
+    }
+    /**
+     * Gets order submerchants with pagination.
+     * Based on `get_order_submerchants` from the Python SDK.
+     */
+    async getOrderSubmerchants(params = {}) {
+        const response = await this.httpClient.get("/order/submerchants", {
+            params: params,
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || "Order submerchants retrieval failed");
+        }
+        return response.data;
+    }
+    /**
+     * Gets checkout URL for an order.
+     * Based on `get_checkout_url` from the Python SDK.
+     */
+    async getCheckoutUrl(referenceId) {
+        const order = await this.getOrder(referenceId);
+        if (order && order.checkout_url) {
+            return order.checkout_url;
+        }
+        throw new Error("Checkout URL not found in order response");
+    }
+    // Utility Methods
+    /**
+     * Verifies webhook signature for security
+     *
+     * @param payload - Raw webhook payload string
+     * @param signature - Webhook signature from headers
+     * @param secret - Your webhook secret key
+     * @returns Promise resolving to true if signature is valid
+     *
+     * @example
+     * ```typescript
+     * const isValid = await sdk.verifyWebhook(
+     *   JSON.stringify(req.body),
+     *   req.headers['x-tapsilat-signature'],
+     *   'your-webhook-secret'
+     * );
+     * ```
+     */
+    async verifyWebhook(payload, signature, secret) {
+        // Implementation would depend on your webhook signature verification method
+        // This is a placeholder implementation
+        const crypto = await import('crypto');
+        const expectedSignature = crypto
+            .createHmac("sha256", secret)
+            .update(payload)
+            .digest("hex");
+        return `sha256=${expectedSignature}` === signature;
+    }
+    /**
+     * Checks API service health and availability
+     *
+     * @returns Promise resolving to service status
+     */
+    async healthCheck() {
+        const response = await this.httpClient.get("/health");
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || "Health check failed");
+        }
+        return response.data;
+    }
+    // Configuration methods
+    /**
+     * Gets current SDK configuration (without sensitive data)
+     *
+     * @returns Copy of current configuration
+     */
+    getConfig() {
+        const { bearerToken, ...safeConfig } = this.config;
+        return {
+            ...safeConfig,
+            hasBearerToken: Boolean(bearerToken),
+        };
+    }
+    /**
+     * Updates SDK configuration
+     *
+     * @param newConfig - Partial configuration to update
+     * @throws {TapsilatValidationError} When Bearer token is invalid
+     */
+    updateConfig(newConfig) {
+        if (newConfig.bearerToken) {
+            validateBearerToken(newConfig.bearerToken);
+        }
+        Object.assign(this.config, newConfig);
+    }
+}
+
+exports.TapsilatAuthenticationError = TapsilatAuthenticationError;
+exports.TapsilatError = TapsilatError;
+exports.TapsilatNetworkError = TapsilatNetworkError;
+exports.TapsilatRateLimitError = TapsilatRateLimitError;
+exports.TapsilatSDK = TapsilatSDK;
+exports.TapsilatValidationError = TapsilatValidationError;
+exports.isValidCurrency = isValidCurrency;
+exports.isValidPaymentMethod = isValidPaymentMethod;
+exports.isValidUrl = isValidUrl;
+exports.sanitizeMetadata = sanitizeMetadata;
+exports.validateEmail = validateEmail;
+exports.validatePaymentRequest = validatePaymentRequest;
+//# sourceMappingURL=index.js.map