xendit-fn 1.0.0 → 1.0.4

package/lib/index.cjs

@@ -264,7 +264,7 @@ const CurrencySchema = zod.z.union([
     zod.z.literal("THB"),
     zod.z.literal("VND")
 ]);
-zod.z.object({
+const BillingDetailSchema = zod.z.object({
     given_names: zod.z.string(),
     surname: zod.z.string().optional(),
     email: zod.z.string().email().optional(),
@@ -326,7 +326,7 @@ const AccountTypeSchema = zod.z.union([
     zod.z.literal("QR_CODE"),
     zod.z.literal("SOCIAL_MEDIA")
 ]);
-const BankAccountSchema = zod.z.object({
+const BankAccountSchema$1 = zod.z.object({
     account_number: zod.z.string(),
     account_holder_name: zod.z.string(),
     swift_code: zod.z.string().optional(),
@@ -361,7 +361,7 @@ const SocialMediaAccountSchema = zod.z.object({
 const PropertiesSchema = zod.z.discriminatedUnion("type", [
     zod.z.object({
         type: zod.z.literal("BANK_ACCOUNT"),
-        properties: BankAccountSchema
+        properties: BankAccountSchema$1
     }),
     zod.z.object({
         type: zod.z.literal("EWALLET"),
@@ -569,8 +569,228 @@ const updateCustomer = async (params, axiosInstance, config)=>{
     }
 };
 
-const createEwalletCharge = async (params, axiosInstance, config)=>(await axiosInstance.post(config?.url ?? "/ewallets/charges", params, config)).data;
-const getEwalletCharge = async (params, axiosInstance, config)=>(await axiosInstance.get(config?.url ?? `/ewallets/charges/${params.id}`, config)).data;
+const CheckoutMethodSchema = zod.z.union([
+    zod.z.literal("ONE_TIME_PAYMENT"),
+    zod.z.literal("TOKENIZED_PAYMENT")
+]);
+const ChannelCodeSchema = zod.z.union([
+    zod.z.literal("ID_OVO"),
+    zod.z.literal("ID_DANA"),
+    zod.z.literal("ID_LINKAJA"),
+    zod.z.literal("ID_SHOPEEPAY"),
+    zod.z.literal("ID_ASTRAPAY"),
+    zod.z.literal("ID_JENIUSPAY"),
+    zod.z.literal("ID_SAKUKU"),
+    zod.z.literal("PH_PAYMAYA"),
+    zod.z.literal("PH_GCASH"),
+    zod.z.literal("PH_GRABPAY"),
+    zod.z.literal("PH_SHOPEEPAY"),
+    zod.z.literal("VN_APPOTA"),
+    zod.z.literal("VN_MOMO"),
+    zod.z.literal("VN_SHOPEEPAY"),
+    zod.z.literal("VN_VNPTWALLET"),
+    zod.z.literal("VN_VIETTELPAY"),
+    zod.z.literal("VN_ZALOPAY"),
+    zod.z.literal("TH_WECHATPAY"),
+    zod.z.literal("TH_LINEPAY"),
+    zod.z.literal("TH_TRUEMONEY"),
+    zod.z.literal("TH_SHOPEEPAY"),
+    zod.z.literal("MY_TOUCHNGO"),
+    zod.z.literal("MY_SHOPEEPAY"),
+    zod.z.literal("MY_GRABPAY")
+]);
+const OVOChannelSchema = zod.z.object({
+    mobile_number: PhoneSchema
+});
+const ChannelsSchema = zod.z.object({
+    cashtag: zod.z.string().refine((value)=>value.startsWith("$")).optional(),
+    mobile_number: PhoneSchema.optional(),
+    success_redirect_url: zod.z.string().url().optional(),
+    failure_redirect_url: zod.z.string().url().optional(),
+    cancel_redirect_url: zod.z.string().url().optional(),
+    redeem_points: zod.z.union([
+        zod.z.literal("REDEEM_ALL"),
+        zod.z.literal("REDEEM_NONE")
+    ]).default("REDEEM_NONE").optional()
+});
+const ChannelPropertiesSchema$1 = zod.z.discriminatedUnion("channel_code", [
+    zod.z.object({
+        channel_code: zod.z.literal("ID_OVO"),
+        channel_properties: OVOChannelSchema
+    }),
+    zod.z.object({
+        channel_code: zod.z.literal("ID_JENIUSPAY"),
+        properties: zod.z.discriminatedUnion("method", [
+            zod.z.object({
+                method: zod.z.literal("ONE_TIME_PAYMENT"),
+                properties: zod.z.object({
+                    cashtag: zod.z.string().refine((value)=>value.startsWith("$"))
+                })
+            }),
+            zod.z.object({
+                method: zod.z.literal("TOKENIZED_PAYMENT"),
+                properties: zod.z.object({
+                    success_redirect_url: zod.z.string().url(),
+                    failure_redirect_url: zod.z.string().url(),
+                    redeem_points: zod.z.union([
+                        zod.z.literal("REDEEM_ALL"),
+                        zod.z.literal("REDEEM_NONE")
+                    ]).default("REDEEM_NONE").optional()
+                })
+            })
+        ])
+    }),
+    zod.z.object({
+        channel_code: zod.z.union([
+            zod.z.literal("ID_DANA"),
+            zod.z.literal("ID_LINKAJA"),
+            zod.z.literal("ID_SHOPEEPAY"),
+            zod.z.literal("PH_SHOPEEPAY"),
+            zod.z.literal("TH_SHOPEEPAY"),
+            zod.z.literal("TH_WECHATPAY"),
+            zod.z.literal("TH_TOUCHNGO"),
+            zod.z.literal("TH_TRUEMONEY"),
+            zod.z.literal("ID_SAKUKU")
+        ]),
+        properties: zod.z.discriminatedUnion("method", [
+            zod.z.object({
+                method: zod.z.literal("ONE_TIME_PAYMENT"),
+                properties: zod.z.object({
+                    success_redirect_url: zod.z.string().url()
+                })
+            }),
+            zod.z.object({
+                method: zod.z.literal("TOKENIZED_PAYMENT"),
+                properties: zod.z.object({
+                    success_redirect_url: zod.z.string().url(),
+                    failure_redirect_url: zod.z.string().url(),
+                    redeem_points: zod.z.union([
+                        zod.z.literal("REDEEM_ALL"),
+                        zod.z.literal("REDEEM_NONE")
+                    ]).default("REDEEM_NONE").optional()
+                })
+            })
+        ])
+    }),
+    zod.z.object({
+        channel_code: zod.z.literal("PH_PAYMAYA"),
+        properties: zod.z.object({
+            success_redirect_url: zod.z.string().url(),
+            failure_redirect_url: zod.z.string().url(),
+            cancel_redirect_url: zod.z.string().url()
+        })
+    })
+]);
+const LineItemSchema = zod.z.object({
+    reference_id: zod.z.string(),
+    name: zod.z.string(),
+    category: zod.z.string(),
+    currency: CurrencySchema,
+    price: zod.z.number(),
+    quantity: zod.z.number(),
+    type: zod.z.union([
+        zod.z.literal("PRODUCT"),
+        zod.z.literal("SERVICE")
+    ]),
+    url: zod.z.string().url().optional(),
+    description: zod.z.string().optional(),
+    subcategory: zod.z.string().optional(),
+    metadata: zod.z.object({}).optional()
+});
+// Create a discriminated union based on checkout method
+const EWalletChargeSchema = zod.z.discriminatedUnion("checkout_method", [
+    zod.z.object({
+        reference_id: zod.z.string(),
+        currency: CurrencySchema,
+        amount: zod.z.number(),
+        checkout_method: zod.z.literal("ONE_TIME_PAYMENT"),
+        channel_code: ChannelCodeSchema,
+        channel_properties: ChannelsSchema,
+        payment_method_id: zod.z.undefined().optional(),
+        customer_id: zod.z.string().optional(),
+        basket: zod.z.array(LineItemSchema).optional(),
+        metadata: zod.z.object({}).optional()
+    }),
+    zod.z.object({
+        reference_id: zod.z.string(),
+        currency: CurrencySchema,
+        amount: zod.z.number(),
+        checkout_method: zod.z.literal("TOKENIZED_PAYMENT"),
+        channel_code: ChannelCodeSchema.optional(),
+        channel_properties: ChannelsSchema,
+        payment_method_id: zod.z.string(),
+        customer_id: zod.z.string().optional(),
+        basket: zod.z.array(LineItemSchema).optional(),
+        metadata: zod.z.object({}).optional()
+    })
+]);
+const EWalletStatusSchema = zod.z.union([
+    zod.z.literal("SUCCEEDED"),
+    zod.z.literal("PENDING"),
+    zod.z.literal("FAILED"),
+    zod.z.literal("VOIDED"),
+    zod.z.literal("REFUNDED")
+]);
+const EWalletResourceActionsSchema = zod.z.object({
+    desktop_web_checkout_url: zod.z.string().url().optional(),
+    mobile_web_checkout_url: zod.z.string().url().optional(),
+    mobile_deeplink_checkout_url: zod.z.string().url().optional(),
+    qr_checkout_string: zod.z.string().url().optional()
+});
+const EWalletChargeResourceSchema = zod.z.object({
+    id: zod.z.string(),
+    business_id: zod.z.string(),
+    reference_id: zod.z.string(),
+    status: EWalletStatusSchema,
+    currency: CurrencySchema,
+    charge_amount: zod.z.number(),
+    capture_amount: zod.z.number().optional(),
+    refunded_amount: zod.z.number().nullable(),
+    checkout_method: CheckoutMethodSchema,
+    channel_code: ChannelCodeSchema,
+    channel_properties: ChannelPropertiesSchema$1,
+    actions: EWalletResourceActionsSchema.optional(),
+    is_redirect_required: zod.z.boolean(),
+    callback_url: zod.z.string(),
+    created: zod.z.string().datetime(),
+    updated: zod.z.string().datetime(),
+    void_status: zod.z.string().nullable(),
+    voided_at: zod.z.string().nullable(),
+    capture_now: zod.z.boolean(),
+    customer_id: zod.z.string().nullable(),
+    payment_method_id: zod.z.string().nullable(),
+    failure_code: zod.z.string().nullable(),
+    basket: zod.z.array(LineItemSchema).optional(),
+    metadata: zod.z.object({}).optional()
+});
+const GetEWalletChargeSchema = zod.z.object({
+    id: zod.z.string().startsWith("ewc")
+});
+
+const createEwalletCharge = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(EWalletChargeSchema, params, "ewallet charge params");
+        const response = await axiosInstance.post(config?.url ?? "/ewallets/charges", validatedParams, config);
+        return validateInput(EWalletChargeResourceSchema, response.data, "ewallet charge response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const getEwalletCharge = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(GetEWalletChargeSchema, params, "get ewallet charge params");
+        const response = await axiosInstance.get(config?.url ?? `/ewallets/charges/${validatedParams.id}`, config);
+        return validateInput(EWalletChargeResourceSchema, response.data, "ewallet charge response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
 
 // Payment Method Types
 const PaymentMethodTypeSchema = zod.z.union([
@@ -806,6 +1026,9 @@ const listPaymentMethods = async (params, axiosInstance, config)=>{
         }
         const queryString = queryParams.toString();
         const url = queryString ? `/v2/payment_methods?${queryString}` : "/v2/payment_methods";
+        if (!axiosInstance) {
+            throw new Error("axiosInstance is required");
+        }
         const response = await axiosInstance.get(config?.url ?? url, config);
         return response.data;
     } catch (error) {
@@ -1122,6 +1345,9 @@ const listInvoices = async (params, axiosInstance, config)=>{
         }
         const queryString = queryParams.toString();
         const url = queryString ? `/v2/invoices?${queryString}` : "/v2/invoices";
+        if (!axiosInstance) {
+            throw new Error("axiosInstance is required");
+        }
         const response = await axiosInstance.get(config?.url ?? url, config);
         return response.data;
     } catch (error) {
@@ -1156,51 +1382,1055 @@ const expireInvoice = async (params, axiosInstance, config)=>{
     }
 };
 
-const btoa = (string)=>{
-    if (typeof window === "undefined") {
-        return Buffer.from(string).toString("base64");
+// Payment Request Types
+const PaymentRequestTypeSchema = zod.z.union([
+    zod.z.literal("PAY"),
+    zod.z.literal("PAY_AND_SAVE"),
+    zod.z.literal("REUSABLE_PAYMENT_CODE")
+]);
+// Capture Method
+const CaptureMethodSchema = zod.z.union([
+    zod.z.literal("AUTOMATIC"),
+    zod.z.literal("MANUAL")
+]);
+// Payment Request Status
+const PaymentRequestStatusSchema = zod.z.union([
+    zod.z.literal("PENDING"),
+    zod.z.literal("REQUIRES_ACTION"),
+    zod.z.literal("SUCCEEDED"),
+    zod.z.literal("FAILED"),
+    zod.z.literal("VOIDED"),
+    zod.z.literal("CANCELED")
+]);
+// Channel Code (simplified - can be expanded)
+zod.z.string();
+// Channel Properties
+const ChannelPropertiesSchema = zod.z.record(zod.z.unknown());
+// Payment Method
+const PaymentMethodSchema = zod.z.object({
+    type: zod.z.string(),
+    card_information: zod.z.object({
+        token_id: zod.z.string()
+    }).optional(),
+    ewallet: zod.z.object({
+        channel_code: zod.z.string(),
+        channel_properties: ChannelPropertiesSchema.optional()
+    }).optional(),
+    direct_debit: zod.z.object({
+        channel_code: zod.z.string(),
+        channel_properties: ChannelPropertiesSchema.optional()
+    }).optional(),
+    over_the_counter: zod.z.object({
+        channel_code: zod.z.string(),
+        channel_properties: ChannelPropertiesSchema.optional()
+    }).optional(),
+    qr_code: zod.z.object({
+        channel_code: zod.z.string(),
+        channel_properties: ChannelPropertiesSchema.optional()
+    }).optional(),
+    virtual_account: zod.z.object({
+        channel_code: zod.z.string(),
+        channel_properties: ChannelPropertiesSchema.optional()
+    }).optional()
+});
+// Create Payment Request Schema
+const CreatePaymentRequestSchema = zod.z.object({
+    reference_id: zod.z.string(),
+    type: PaymentRequestTypeSchema,
+    country: CountrySchema,
+    currency: CurrencySchema,
+    request_amount: zod.z.number().positive(),
+    payment_method: PaymentMethodSchema,
+    description: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.unknown()).optional(),
+    customer_id: zod.z.string().optional(),
+    customer: zod.z.object({
+        given_names: zod.z.string(),
+        surname: zod.z.string().optional(),
+        email: zod.z.string().email().optional(),
+        mobile_number: zod.z.string().optional()
+    }).optional(),
+    shipping_information: zod.z.object({
+        name: zod.z.string(),
+        phone_number: zod.z.string().optional(),
+        address: zod.z.string().optional(),
+        city: zod.z.string().optional(),
+        province: zod.z.string().optional(),
+        postal_code: zod.z.string().optional(),
+        country_code: CountrySchema.optional()
+    }).optional(),
+    items: zod.z.array(zod.z.object({
+        name: zod.z.string(),
+        quantity: zod.z.number().positive(),
+        price: zod.z.number().positive(),
+        category: zod.z.string().optional(),
+        reference_id: zod.z.string().optional(),
+        url: zod.z.string().url().optional()
+    })).optional(),
+    capture_method: CaptureMethodSchema.optional(),
+    success_redirect_url: zod.z.string().url().optional(),
+    failure_redirect_url: zod.z.string().url().optional()
+});
+// Payment Request Resource
+const PaymentRequestResourceSchema = zod.z.object({
+    id: zod.z.string(),
+    reference_id: zod.z.string(),
+    type: PaymentRequestTypeSchema,
+    country: CountrySchema,
+    currency: CurrencySchema,
+    request_amount: zod.z.number(),
+    paid_amount: zod.z.number().optional(),
+    status: PaymentRequestStatusSchema,
+    payment_method: PaymentMethodSchema,
+    description: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.unknown()).optional(),
+    customer_id: zod.z.string().optional(),
+    customer: zod.z.object({
+        given_names: zod.z.string(),
+        surname: zod.z.string().optional(),
+        email: zod.z.string().email().optional(),
+        mobile_number: zod.z.string().optional()
+    }).optional(),
+    shipping_information: zod.z.object({
+        name: zod.z.string(),
+        phone_number: zod.z.string().optional(),
+        address: zod.z.string().optional(),
+        city: zod.z.string().optional(),
+        province: zod.z.string().optional(),
+        postal_code: zod.z.string().optional(),
+        country_code: CountrySchema.optional()
+    }).optional(),
+    items: zod.z.array(zod.z.object({
+        name: zod.z.string(),
+        quantity: zod.z.number().positive(),
+        price: zod.z.number().positive(),
+        category: zod.z.string().optional(),
+        reference_id: zod.z.string().optional(),
+        url: zod.z.string().url().optional()
+    })).optional(),
+    actions: zod.z.object({
+        desktop_web_checkout_url: zod.z.string().url().optional(),
+        mobile_web_checkout_url: zod.z.string().url().optional(),
+        mobile_deeplink_checkout_url: zod.z.string().url().optional(),
+        qr_checkout_string: zod.z.string().optional()
+    }).optional(),
+    created: zod.z.string().datetime(),
+    updated: zod.z.string().datetime(),
+    failure_reason: zod.z.string().optional(),
+    payment_request_id: zod.z.string().optional()
+});
+// Get Payment Request Schema
+const GetPaymentRequestSchema = zod.z.object({
+    id: zod.z.string()
+});
+// List Payment Requests Schema
+const ListPaymentRequestsSchema = zod.z.object({
+    reference_id: zod.z.string().optional(),
+    customer_id: zod.z.string().optional(),
+    status: zod.z.array(PaymentRequestStatusSchema).optional(),
+    limit: zod.z.number().min(1).max(100).optional(),
+    after_id: zod.z.string().optional(),
+    before_id: zod.z.string().optional(),
+    created_after: zod.z.string().datetime().optional(),
+    created_before: zod.z.string().datetime().optional()
+});
+// List Payment Requests Response
+zod.z.object({
+    data: zod.z.array(PaymentRequestResourceSchema),
+    has_more: zod.z.boolean(),
+    links: zod.z.array(zod.z.object({
+        href: zod.z.string(),
+        rel: zod.z.string(),
+        method: zod.z.string()
+    })).optional()
+});
+
+const createPaymentRequest = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(CreatePaymentRequestSchema, params, "payment request params");
+        const response = await axiosInstance.post(config?.url ?? "/v3/payment_requests", validatedParams, {
+            ...config,
+            headers: {
+                "api-version": "2024-11-11",
+                ...config?.headers
+            }
+        });
+        return validateInput(PaymentRequestResourceSchema, response.data, "payment request response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
     }
-    return window.btoa(string);
 };
-const createFn = (fn, axiosInstance)=>{
-    return (data)=>fn(data, axiosInstance);
+const getPaymentRequest = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(GetPaymentRequestSchema, params, "get payment request params");
+        const response = await axiosInstance.get(config?.url ?? `/v3/payment_requests/${validatedParams.id}`, {
+            ...config,
+            headers: {
+                "api-version": "2024-11-11",
+                ...config?.headers
+            }
+        });
+        return validateInput(PaymentRequestResourceSchema, response.data, "payment request response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
 };
-const Xendit = (key, options = {})=>{
-    const axiosInstance = createAxiosInstance({
-        headers: {
-            Authorization: `Basic ${btoa(key + ":")}`
+const listPaymentRequests = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = params ? validateInput(ListPaymentRequestsSchema, params, "list payment requests params") : {};
+        const queryParams = new URLSearchParams();
+        if (validatedParams.reference_id) {
+            queryParams.append("reference_id", validatedParams.reference_id);
         }
-    });
-    // Apply rate limiting if configured
-    if (options.rateLimit) {
-        setupRateLimit(axiosInstance, options.rateLimit);
+        if (validatedParams.customer_id) {
+            queryParams.append("customer_id", validatedParams.customer_id);
+        }
+        if (validatedParams.status) {
+            validatedParams.status.forEach((status)=>queryParams.append("status[]", status));
+        }
+        if (validatedParams.limit) {
+            queryParams.append("limit", validatedParams.limit.toString());
+        }
+        if (validatedParams.after_id) {
+            queryParams.append("after_id", validatedParams.after_id);
+        }
+        if (validatedParams.before_id) {
+            queryParams.append("before_id", validatedParams.before_id);
+        }
+        if (validatedParams.created_after) {
+            queryParams.append("created_after", validatedParams.created_after);
+        }
+        if (validatedParams.created_before) {
+            queryParams.append("created_before", validatedParams.created_before);
+        }
+        const queryString = queryParams.toString();
+        const url = queryString ? `/v3/payment_requests?${queryString}` : "/v3/payment_requests";
+        if (!axiosInstance) {
+            throw new Error("axiosInstance is required");
+        }
+        const response = await axiosInstance.get(config?.url ?? url, {
+            ...config,
+            headers: {
+                "api-version": "2024-11-11",
+                ...config?.headers
+            }
+        });
+        return response.data;
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
     }
-    if (key.includes("development")) {
-        console.log("👾 You are on → TEST MODE");
+};
+
+// Refund Reason
+const RefundReasonSchema = zod.z.union([
+    zod.z.literal("REQUESTED_BY_CUSTOMER"),
+    zod.z.literal("FRAUDULENT"),
+    zod.z.literal("DUPLICATE"),
+    zod.z.literal("CANCELLATION"),
+    zod.z.literal("OTHERS")
+]);
+// Refund Status
+const RefundStatusSchema = zod.z.union([
+    zod.z.literal("PENDING"),
+    zod.z.literal("SUCCEEDED"),
+    zod.z.literal("FAILED")
+]);
+// Create Refund Schema
+const CreateRefundSchema = zod.z.object({
+    payment_request_id: zod.z.string(),
+    amount: zod.z.number().positive().optional(),
+    reason: RefundReasonSchema,
+    metadata: zod.z.record(zod.z.unknown()).optional()
+});
+// Refund Resource
+const RefundResourceSchema = zod.z.object({
+    id: zod.z.string(),
+    payment_request_id: zod.z.string(),
+    amount: zod.z.number(),
+    currency: zod.z.string(),
+    reason: RefundReasonSchema,
+    status: RefundStatusSchema,
+    metadata: zod.z.record(zod.z.unknown()).optional(),
+    created: zod.z.string().datetime(),
+    updated: zod.z.string().datetime(),
+    failure_reason: zod.z.string().optional()
+});
+// Get Refund Schema
+const GetRefundSchema = zod.z.object({
+    id: zod.z.string()
+});
+// List Refunds Schema
+const ListRefundsSchema = zod.z.object({
+    payment_request_id: zod.z.string().optional(),
+    limit: zod.z.number().min(1).max(100).optional(),
+    after_id: zod.z.string().optional(),
+    before_id: zod.z.string().optional(),
+    created_after: zod.z.string().datetime().optional(),
+    created_before: zod.z.string().datetime().optional()
+});
+// List Refunds Response
+zod.z.object({
+    data: zod.z.array(RefundResourceSchema),
+    has_more: zod.z.boolean(),
+    links: zod.z.array(zod.z.object({
+        href: zod.z.string(),
+        rel: zod.z.string(),
+        method: zod.z.string()
+    })).optional()
+});
+
+const createRefund = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(CreateRefundSchema, params, "refund params");
+        const response = await axiosInstance.post(config?.url ?? "/v3/refunds", validatedParams, {
+            ...config,
+            headers: {
+                "api-version": "2024-11-11",
+                ...config?.headers
+            }
+        });
+        return validateInput(RefundResourceSchema, response.data, "refund response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
     }
-    return {
-        customer: {
-            create: createFn(createCustomer, axiosInstance),
-            getById: createFn(getCustomerId, axiosInstance),
-            getByRefId: createFn(getCustomerRefId, axiosInstance),
-            update: createFn(updateCustomer, axiosInstance)
-        },
-        ewallet: {
-            charge: createFn(createEwalletCharge, axiosInstance),
-            get: createFn(getEwalletCharge, axiosInstance)
-        },
-        paymentMethod: {
-            create: createFn(createPaymentMethod, axiosInstance),
-            get: createFn(getPaymentMethod, axiosInstance),
-            list: (params)=>listPaymentMethods(params, axiosInstance),
-            update: createFn(updatePaymentMethod, axiosInstance)
-        },
-        invoice: {
-            create: createFn(createInvoice, axiosInstance),
-            get: createFn(getInvoice, axiosInstance),
-            list: (params)=>listInvoices(params, axiosInstance),
-            update: createFn(updateInvoice, axiosInstance),
+};
+const getRefund = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(GetRefundSchema, params, "get refund params");
+        const response = await axiosInstance.get(config?.url ?? `/v3/refunds/${validatedParams.id}`, {
+            ...config,
+            headers: {
+                "api-version": "2024-11-11",
+                ...config?.headers
+            }
+        });
+        return validateInput(RefundResourceSchema, response.data, "refund response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const listRefunds = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = params ? validateInput(ListRefundsSchema, params, "list refunds params") : {};
+        const queryParams = new URLSearchParams();
+        if (validatedParams.payment_request_id) {
+            queryParams.append("payment_request_id", validatedParams.payment_request_id);
+        }
+        if (validatedParams.limit) {
+            queryParams.append("limit", validatedParams.limit.toString());
+        }
+        if (validatedParams.after_id) {
+            queryParams.append("after_id", validatedParams.after_id);
+        }
+        if (validatedParams.before_id) {
+            queryParams.append("before_id", validatedParams.before_id);
+        }
+        if (validatedParams.created_after) {
+            queryParams.append("created_after", validatedParams.created_after);
+        }
+        if (validatedParams.created_before) {
+            queryParams.append("created_before", validatedParams.created_before);
+        }
+        const queryString = queryParams.toString();
+        const url = queryString ? `/v3/refunds?${queryString}` : "/v3/refunds";
+        if (!axiosInstance) {
+            throw new Error("axiosInstance is required");
+        }
+        const response = await axiosInstance.get(config?.url ?? url, {
+            ...config,
+            headers: {
+                "api-version": "2024-11-11",
+                ...config?.headers
+            }
+        });
+        return response.data;
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+
+// Payout Status
+const PayoutStatusSchema = zod.z.union([
+    zod.z.literal("ACCEPTED"),
+    zod.z.literal("PENDING"),
+    zod.z.literal("PROCESSING"),
+    zod.z.literal("COMPLETED"),
+    zod.z.literal("FAILED"),
+    zod.z.literal("CANCELLED"),
+    zod.z.literal("REVERSED")
+]);
+// Payout Channel Code
+const PayoutChannelCodeSchema = zod.z.union([
+    zod.z.literal("BANK"),
+    zod.z.literal("EWALLET"),
+    zod.z.literal("CASH")
+]);
+// Bank Account
+const BankAccountSchema = zod.z.object({
+    account_holder_name: zod.z.string(),
+    account_number: zod.z.string(),
+    bank_code: zod.z.string(),
+    account_type: zod.z.string().optional()
+});
+// E-wallet Account
+const EwalletAccountSchema = zod.z.object({
+    account_holder_name: zod.z.string(),
+    account_number: zod.z.string(),
+    ewallet_type: zod.z.string()
+});
+// Payout Method
+const PayoutMethodSchema = zod.z.discriminatedUnion("channel_code", [
+    zod.z.object({
+        channel_code: zod.z.literal("BANK"),
+        bank_account: BankAccountSchema
+    }),
+    zod.z.object({
+        channel_code: zod.z.literal("EWALLET"),
+        ewallet: EwalletAccountSchema
+    }),
+    zod.z.object({
+        channel_code: zod.z.literal("CASH"),
+        cash: zod.z.object({
+            account_holder_name: zod.z.string(),
+            account_number: zod.z.string()
+        })
+    })
+]);
+// Create Payout Schema
+const CreatePayoutSchema = zod.z.object({
+    reference_id: zod.z.string(),
+    channel_code: PayoutChannelCodeSchema,
+    channel_properties: PayoutMethodSchema,
+    amount: zod.z.number().positive(),
+    currency: CurrencySchema,
+    description: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.unknown()).optional(),
+    receipt_notification: zod.z.object({
+        email_to: zod.z.array(zod.z.string().email()).optional(),
+        email_cc: zod.z.array(zod.z.string().email()).optional(),
+        email_bcc: zod.z.array(zod.z.string().email()).optional()
+    }).optional()
+});
+// Payout Resource
+const PayoutResourceSchema = zod.z.object({
+    id: zod.z.string(),
+    reference_id: zod.z.string(),
+    channel_code: PayoutChannelCodeSchema,
+    channel_properties: PayoutMethodSchema,
+    amount: zod.z.number(),
+    currency: CurrencySchema,
+    status: PayoutStatusSchema,
+    description: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.unknown()).optional(),
+    created: zod.z.string().datetime(),
+    updated: zod.z.string().datetime(),
+    failure_reason: zod.z.string().optional(),
+    estimated_arrival_time: zod.z.string().datetime().optional(),
+    receipt_notification: zod.z.object({
+        email_to: zod.z.array(zod.z.string().email()).optional(),
+        email_cc: zod.z.array(zod.z.string().email()).optional(),
+        email_bcc: zod.z.array(zod.z.string().email()).optional()
+    }).optional()
+});
+// Get Payout Schema
+const GetPayoutSchema = zod.z.object({
+    id: zod.z.string()
+});
+// List Payouts Schema
+const ListPayoutsSchema = zod.z.object({
+    reference_id: zod.z.string().optional(),
+    channel_code: zod.z.array(PayoutChannelCodeSchema).optional(),
+    status: zod.z.array(PayoutStatusSchema).optional(),
+    limit: zod.z.number().min(1).max(100).optional(),
+    after_id: zod.z.string().optional(),
+    before_id: zod.z.string().optional(),
+    created_after: zod.z.string().datetime().optional(),
+    created_before: zod.z.string().datetime().optional()
+});
+// List Payouts Response
+zod.z.object({
+    data: zod.z.array(PayoutResourceSchema),
+    has_more: zod.z.boolean(),
+    links: zod.z.array(zod.z.object({
+        href: zod.z.string(),
+        rel: zod.z.string(),
+        method: zod.z.string()
+    })).optional()
+});
+// Cancel Payout Schema
+const CancelPayoutSchema = zod.z.object({
+    id: zod.z.string()
+});
+
+const createPayout = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(CreatePayoutSchema, params, "payout params");
+        const response = await axiosInstance.post(config?.url ?? "/v2/payouts", validatedParams, config);
+        return validateInput(PayoutResourceSchema, response.data, "payout response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const getPayout = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(GetPayoutSchema, params, "get payout params");
+        const response = await axiosInstance.get(config?.url ?? `/v2/payouts/${validatedParams.id}`, config);
+        return validateInput(PayoutResourceSchema, response.data, "payout response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const listPayouts = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = params ? validateInput(ListPayoutsSchema, params, "list payouts params") : {};
+        const queryParams = new URLSearchParams();
+        if (validatedParams.reference_id) {
+            queryParams.append("reference_id", validatedParams.reference_id);
+        }
+        if (validatedParams.channel_code) {
+            validatedParams.channel_code.forEach((code)=>queryParams.append("channel_code[]", code));
+        }
+        if (validatedParams.status) {
+            validatedParams.status.forEach((status)=>queryParams.append("status[]", status));
+        }
+        if (validatedParams.limit) {
+            queryParams.append("limit", validatedParams.limit.toString());
+        }
+        if (validatedParams.after_id) {
+            queryParams.append("after_id", validatedParams.after_id);
+        }
+        if (validatedParams.before_id) {
+            queryParams.append("before_id", validatedParams.before_id);
+        }
+        if (validatedParams.created_after) {
+            queryParams.append("created_after", validatedParams.created_after);
+        }
+        if (validatedParams.created_before) {
+            queryParams.append("created_before", validatedParams.created_before);
+        }
+        const queryString = queryParams.toString();
+        const url = queryString ? `/v2/payouts?${queryString}` : "/v2/payouts";
+        if (!axiosInstance) {
+            throw new Error("axiosInstance is required");
+        }
+        const response = await axiosInstance.get(config?.url ?? url, config);
+        return response.data;
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const cancelPayout = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(CancelPayoutSchema, params, "cancel payout params");
+        const response = await axiosInstance.post(config?.url ?? `/v2/payouts/${validatedParams.id}/cancel`, {}, config);
+        return validateInput(PayoutResourceSchema, response.data, "payout response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+
+// Balance Resource
+const BalanceResourceSchema = zod.z.object({
+    balance: zod.z.number(),
+    currency: CurrencySchema,
+    account_type: zod.z.string().optional()
+});
+// Transaction Type
+const TransactionTypeSchema = zod.z.union([
+    zod.z.literal("PAYMENT"),
+    zod.z.literal("PAYOUT"),
+    zod.z.literal("REFUND"),
+    zod.z.literal("FEE"),
+    zod.z.literal("ADJUSTMENT")
+]);
+// Transaction Status
+const TransactionStatusSchema = zod.z.union([
+    zod.z.literal("PENDING"),
+    zod.z.literal("SUCCEEDED"),
+    zod.z.literal("FAILED"),
+    zod.z.literal("CANCELLED")
+]);
+// Transaction Resource
+const TransactionResourceSchema = zod.z.object({
+    id: zod.z.string(),
+    reference_id: zod.z.string().optional(),
+    type: TransactionTypeSchema,
+    status: TransactionStatusSchema,
+    amount: zod.z.number(),
+    currency: CurrencySchema,
+    created: zod.z.string().datetime(),
+    updated: zod.z.string().datetime(),
+    description: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.unknown()).optional()
+});
+// List Transactions Schema
+const ListTransactionsSchema = zod.z.object({
+    types: zod.z.array(TransactionTypeSchema).optional(),
+    statuses: zod.z.array(TransactionStatusSchema).optional(),
+    limit: zod.z.number().min(1).max(100).optional(),
+    after_id: zod.z.string().optional(),
+    before_id: zod.z.string().optional(),
+    created_after: zod.z.string().datetime().optional(),
+    created_before: zod.z.string().datetime().optional()
+});
+// List Transactions Response
+zod.z.object({
+    data: zod.z.array(TransactionResourceSchema),
+    has_more: zod.z.boolean(),
+    links: zod.z.array(zod.z.object({
+        href: zod.z.string(),
+        rel: zod.z.string(),
+        method: zod.z.string()
+    })).optional()
+});
+
+const getBalance = async (axiosInstance, config)=>{
+    try {
+        const response = await axiosInstance.get(config?.url ?? "/balance", config);
+        return validateInput(BalanceResourceSchema, response.data, "balance response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const listTransactions = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = params ? validateInput(ListTransactionsSchema, params, "list transactions params") : {};
+        const queryParams = new URLSearchParams();
+        if (validatedParams.types) {
+            validatedParams.types.forEach((type)=>queryParams.append("types[]", type));
+        }
+        if (validatedParams.statuses) {
+            validatedParams.statuses.forEach((status)=>queryParams.append("statuses[]", status));
+        }
+        if (validatedParams.limit) {
+            queryParams.append("limit", validatedParams.limit.toString());
+        }
+        if (validatedParams.after_id) {
+            queryParams.append("after_id", validatedParams.after_id);
+        }
+        if (validatedParams.before_id) {
+            queryParams.append("before_id", validatedParams.before_id);
+        }
+        if (validatedParams.created_after) {
+            queryParams.append("created_after", validatedParams.created_after);
+        }
+        if (validatedParams.created_before) {
+            queryParams.append("created_before", validatedParams.created_before);
+        }
+        const queryString = queryParams.toString();
+        const url = queryString ? `/transactions?${queryString}` : "/transactions";
+        if (!axiosInstance) {
+            throw new Error("axiosInstance is required");
+        }
+        const response = await axiosInstance.get(config?.url ?? url, config);
+        return response.data;
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+
+const CardDataSchema = zod.z.object({
+    account_number: zod.z.string(),
+    exp_month: zod.z.string(),
+    exp_year: zod.z.string(),
+    card_holder_first_name: zod.z.string(),
+    card_holder_last_name: zod.z.string(),
+    card_holder_email: zod.z.string().email(),
+    card_holder_phone_number: PhoneSchema
+});
+const TokenParamsSchema = zod.z.object({
+    amount: zod.z.string().optional(),
+    card_data: CardDataSchema.optional(),
+    external_id: zod.z.string().optional(),
+    card_cvn: zod.z.string().min(3).max(3).optional(),
+    is_multiple_use: zod.z.boolean().optional().default(false),
+    currency: CurrencySchema.optional(),
+    should_authenticate: zod.z.boolean().default(true),
+    billing_details: AddressSchema.optional(),
+    mid_label: zod.z.string()
+});
+const TokenStatusSchema = zod.z.union([
+    zod.z.literal("IN_REVIEW"),
+    zod.z.literal("VERIFIED"),
+    zod.z.literal("FAILED"),
+    zod.z.literal("SUCCEEDED"),
+    zod.z.literal("CAPTURED"),
+    zod.z.literal("REVERSED"),
+    zod.z.literal("AUTHORISED")
+]);
+const CardTypeSchema = zod.z.union([
+    zod.z.literal("CREDIT"),
+    zod.z.literal("DEBIT"),
+    zod.z.literal("PREPAID"),
+    zod.z.literal("UNKNOWN")
+]);
+const CardBrandSchema = zod.z.union([
+    zod.z.literal("VISA"),
+    zod.z.literal("MASTERCARD"),
+    zod.z.literal("JCB"),
+    zod.z.literal("AMEX")
+]);
+const TokenFailureReasonSchema = zod.z.union([
+    zod.z.literal("AUTHENTICATION_FAILED"),
+    zod.z.literal("REVERSE_AUTHORIZATION_REJECTED_BY_BANK"),
+    zod.z.literal("PROCESSOR_ERROR")
+]);
+zod.z.union([
+    zod.z.literal("API_VALIDATION_ERROR"),
+    zod.z.literal("INVALID_JSON_FORMAT"),
+    zod.z.literal("ACCOUNT_NUMBER_INVALID_ERROR"),
+    zod.z.literal("VALIDATION_ERROR"),
+    zod.z.literal("BRAND_NOT_SUPPORTED_ERROR"),
+    zod.z.literal("AUTHENTICATION_REQUIRED_ERROR"),
+    zod.z.literal("REQUEST_FORBIDDEN_ERROR"),
+    zod.z.literal("VERIFICATION_TIMEOUT_ERROR"),
+    zod.z.literal("TEMPORARY_SERVICE_ERROR"),
+    zod.z.literal("CONNECTION_ERROR")
+]);
+const CardInfoSchema = zod.z.object({
+    bank: zod.z.string().optional(),
+    country: CountrySchema.optional(),
+    type: CardTypeSchema.optional(),
+    brand: CardBrandSchema.optional(),
+    fingerprint: zod.z.string().optional(),
+    card_art_url: zod.z.string().url().optional()
+});
+const TokenResourceSchema = zod.z.object({
+    id: zod.z.string(),
+    business_id: zod.z.string().optional(),
+    created: zod.z.string().datetime(),
+    authentication_id: zod.z.string(),
+    external_id: zod.z.string(),
+    masked_card_number: zod.z.string(),
+    status: zod.z.string(),
+    payer_authentication_url: zod.z.string().url().optional(),
+    failure_reason: zod.z.string().optional(),
+    card_info: CardInfoSchema.optional()
+});
+const GetTokemParamsSchema = zod.z.object({
+    credit_card_token_id: zod.z.string()
+});
+const TokenAuthenticationSchema = zod.z.object({
+    amount: zod.z.string().optional(),
+    token_id: zod.z.string().optional(),
+    card_data: CardDataSchema.optional(),
+    external_id: zod.z.string().optional(),
+    currency: CurrencySchema.optional(),
+    mid_label: zod.z.string().optional()
+});
+const TokenAuthenticationResourceSchema = zod.z.object({
+    id: zod.z.string(),
+    status: TokenStatusSchema,
+    external_id: zod.z.string().optional(),
+    payer_authentication_url: zod.z.string().url().optional(),
+    mid_label: zod.z.string().optional(),
+    failure_reason: TokenFailureReasonSchema.optional()
+});
+const TokenAuthorizationSchema = zod.z.object({
+    amount: zod.z.string().optional(),
+    token_id: zod.z.string().optional(),
+    capture: zod.z.boolean().default(false),
+    external_id: zod.z.string().optional(),
+    authentication_id: zod.z.string().optional()
+});
+const ZeroAuthorizationSchema = zod.z.object({
+    amount: zod.z.string().default("0"),
+    token_id: zod.z.string().optional(),
+    capture: zod.z.boolean().default(false),
+    external_id: zod.z.string().optional(),
+    authentication_id: zod.z.string().optional()
+});
+const ReverseAuthorizationSchema = zod.z.object({
+    external_id: zod.z.string()
+});
+const PromotionSummarySchema = zod.z.object({
+    reference_id: zod.z.string(),
+    original_amount: zod.z.number()
+});
+const IntervalSchema = zod.z.literal("month");
+const InstallmentSummary = zod.z.object({
+    count: zod.z.number().optional(),
+    interval: IntervalSchema.optional()
+});
+const ECICodeSchema = zod.z.union([
+    zod.z.literal("0"),
+    zod.z.literal("1"),
+    zod.z.literal("2"),
+    zod.z.literal("3"),
+    zod.z.literal("4"),
+    zod.z.literal("5")
+]);
+const CVNCodeSchema = zod.z.union([
+    zod.z.literal("M"),
+    zod.z.literal("N"),
+    zod.z.literal("P")
+]);
+const CreateChargeSchema = zod.z.object({
+    token_id: zod.z.string(),
+    external_id: zod.z.string(),
+    amount: zod.z.number(),
+    authentication_id: zod.z.string().optional(),
+    capture: zod.z.boolean().optional().default(false),
+    descriptor: zod.z.string().optional(),
+    currency: CurrencySchema.optional(),
+    mid_label: zod.z.string().optional(),
+    billing_details: BillingDetailSchema.optional(),
+    promotion: PromotionSummarySchema.optional(),
+    installment: InstallmentSummary.optional(),
+    metadata: zod.z.object({}).optional()
+});
+const ChargeFailureReasonSchema = zod.z.union([
+    zod.z.literal("AUTHENTICATION_FAILED"),
+    zod.z.literal("DECLINED_BY_ISSUER"),
+    zod.z.literal("DECLINED_BY_PROCESSOR"),
+    zod.z.literal("EXPIRED_CARD"),
+    zod.z.literal("ISSUER_SUSPECT_FRAUD"),
+    zod.z.literal("INACTIVE_OR_UNAUTHORIZED_CARD"),
+    zod.z.literal("INSUFFICIENT_BALANCE"),
+    zod.z.literal("INVALID_CARD"),
+    zod.z.literal("INVALID_CVV"),
+    zod.z.literal("ISSUER_UNAVAILABLE"),
+    zod.z.literal("PROCESSOR_ERROR"),
+    zod.z.literal("STOLEN_CARD"),
+    zod.z.literal("PROCESSOR_TIMEOUT"),
+    zod.z.literal("FRAUD_RISK_BLOCKED")
+]);
+const ChargeTypeSchema = zod.z.union([
+    zod.z.literal("SINGLE_USE_TOKEN"),
+    zod.z.literal("MULTIPLE_USE_TOKEN"),
+    zod.z.literal("RECURRING")
+]);
+const ChargeResourceSchema = zod.z.object({
+    created: zod.z.string().datetime(),
+    status: TokenStatusSchema,
+    business_id: zod.z.string(),
+    authorized_amount: zod.z.number(),
+    external_id: zod.z.string(),
+    merchant_id: zod.z.string(),
+    merchant_reference_code: zod.z.string(),
+    card_type: CardTypeSchema,
+    masked_card_number: zod.z.string(),
+    charge_type: ChargeTypeSchema,
+    card_brand: CardBrandSchema,
+    bank_reconciliation_id: zod.z.string(),
+    failure_reason: ChargeFailureReasonSchema.optional(),
+    eci: ECICodeSchema.optional(),
+    cvn_code: CVNCodeSchema.optional(),
+    capture_amount: zod.z.number().optional(),
+    descriptor: zod.z.string().optional(),
+    id: zod.z.string(),
+    mid_label: zod.z.string().optional(),
+    promotion: PromotionSummarySchema.optional(),
+    installment: InstallmentSummary.optional()
+});
+
+const createToken = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(TokenParamsSchema, params, "token params");
+        const response = await axiosInstance.post(config?.url ?? "/credit_card_tokens", validatedParams, config);
+        return validateInput(TokenResourceSchema, response.data, "token response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const getToken = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(GetTokemParamsSchema, params, "get token params");
+        const response = await axiosInstance.get(config?.url ?? `/credit_card_tokens/${validatedParams.credit_card_token_id}`, config);
+        return validateInput(TokenResourceSchema, response.data, "token response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const authenticateToken = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(TokenAuthenticationSchema, params, "token authentication params");
+        const response = await axiosInstance.post(config?.url ?? "/credit_card_tokens/authenticate", validatedParams, config);
+        return validateInput(TokenAuthenticationResourceSchema, response.data, "token authentication response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const authorizeToken = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(TokenAuthorizationSchema, params, "token authorization params");
+        const response = await axiosInstance.post(config?.url ?? "/credit_card_charges", validatedParams, config);
+        return validateInput(ChargeResourceSchema, response.data, "charge response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const zeroAuthorization = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(ZeroAuthorizationSchema, params, "zero authorization params");
+        const response = await axiosInstance.post(config?.url ?? "/credit_card_charges", validatedParams, config);
+        return validateInput(ChargeResourceSchema, response.data, "charge response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const reverseAuthorization = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(ReverseAuthorizationSchema, params, "reverse authorization params");
+        const response = await axiosInstance.post(config?.url ?? `/credit_card_charges/${validatedParams.external_id}/reverse_authorization`, {}, config);
+        return validateInput(ChargeResourceSchema, response.data, "charge response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const createCharge = async (params, axiosInstance, config)=>{
+    try {
+        const validatedParams = validateInput(CreateChargeSchema, params, "charge params");
+        const response = await axiosInstance.post(config?.url ?? "/credit_card_charges", validatedParams, config);
+        return validateInput(ChargeResourceSchema, response.data, "charge response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+const getCharge = async (params, axiosInstance, config)=>{
+    try {
+        const response = await axiosInstance.get(config?.url ?? `/credit_card_charges/${params.id}`, config);
+        return validateInput(ChargeResourceSchema, response.data, "charge response");
+    } catch (error) {
+        if (error instanceof Error && error.name === "AxiosError") {
+            handleAxiosError(error);
+        }
+        throw error;
+    }
+};
+
+const btoa = (string)=>{
+    if (typeof window === "undefined") {
+        return Buffer.from(string).toString("base64");
+    }
+    return window.btoa(string);
+};
+const createFn = (fn, axiosInstance)=>{
+    return (data)=>fn(data, axiosInstance);
+};
+const Xendit = (key, options = {})=>{
+    const axiosInstance = createAxiosInstance({
+        headers: {
+            Authorization: `Basic ${btoa(key + ":")}`
+        }
+    });
+    // Apply rate limiting if configured
+    if (options.rateLimit) {
+        setupRateLimit(axiosInstance, options.rateLimit);
+    }
+    if (key.includes("development")) {
+        console.log("👾 You are on → TEST MODE");
+    }
+    return {
+        customer: {
+            create: createFn(createCustomer, axiosInstance),
+            getById: createFn(getCustomerId, axiosInstance),
+            getByRefId: createFn(getCustomerRefId, axiosInstance),
+            update: createFn(updateCustomer, axiosInstance)
+        },
+        ewallet: {
+            charge: createFn(createEwalletCharge, axiosInstance),
+            get: createFn(getEwalletCharge, axiosInstance)
+        },
+        paymentMethod: {
+            create: createFn(createPaymentMethod, axiosInstance),
+            get: createFn(getPaymentMethod, axiosInstance),
+            list: (params)=>listPaymentMethods(params, axiosInstance),
+            update: createFn(updatePaymentMethod, axiosInstance)
+        },
+        invoice: {
+            create: createFn(createInvoice, axiosInstance),
+            get: createFn(getInvoice, axiosInstance),
+            list: (params)=>listInvoices(params, axiosInstance),
+            update: createFn(updateInvoice, axiosInstance),
             expire: createFn(expireInvoice, axiosInstance)
+        },
+        paymentRequest: {
+            create: createFn(createPaymentRequest, axiosInstance),
+            get: createFn(getPaymentRequest, axiosInstance),
+            list: (params)=>listPaymentRequests(params, axiosInstance)
+        },
+        refund: {
+            create: createFn(createRefund, axiosInstance),
+            get: createFn(getRefund, axiosInstance),
+            list: (params)=>listRefunds(params, axiosInstance)
+        },
+        payout: {
+            create: createFn(createPayout, axiosInstance),
+            get: createFn(getPayout, axiosInstance),
+            list: (params)=>listPayouts(params, axiosInstance),
+            cancel: createFn(cancelPayout, axiosInstance)
+        },
+        balance: {
+            get: ()=>getBalance(axiosInstance),
+            listTransactions: (params)=>listTransactions(params, axiosInstance)
+        },
+        card: {
+            createToken: createFn(createToken, axiosInstance),
+            getToken: createFn(getToken, axiosInstance),
+            authenticateToken: createFn(authenticateToken, axiosInstance),
+            authorizeToken: createFn(authorizeToken, axiosInstance),
+            zeroAuthorization: createFn(zeroAuthorization, axiosInstance),
+            reverseAuthorization: createFn(reverseAuthorization, axiosInstance),
+            createCharge: createFn(createCharge, axiosInstance),
+            getCharge: createFn(getCharge, axiosInstance)
         }
     };
 };