@adbjs/sdk 0.1.1 → 2.0.0

package/dist/index.cjs

@@ -72,30 +72,35 @@ var BaseResource = class {
   }
   /**
    * Make a GET request
-   * @param T - The generated response type (e.g., GetLinkUnlockResponse)
+   * @template T - The generated response type (e.g., GetLinkUnlockResponse)
+   * @param path - API endpoint path
+   * @param params - Optional query parameters
    * @returns The extracted data from the response (without the { status, data } wrapper)
    */
   async get(path, params) {
-    const clientAny = this.client;
-    return clientAny.get(path, params);
+    return this.client.get(path, params);
   }
   /**
    * Make a POST request
-   * @param T - The generated response type
+   * @template T - The generated response type
+   * @param path - API endpoint path
+   * @param body - Request body
+   * @param params - Optional query parameters
    * @returns The extracted data from the response (without the { status, data } wrapper)
    */
   async post(path, body, params) {
-    const clientAny = this.client;
-    return clientAny.post(path, body, params);
+    return this.client.post(path, body, params);
   }
   /**
    * Make a POST request with FormData (multipart/form-data)
-   * @param T - The generated response type
+   * @template T - The generated response type
+   * @param path - API endpoint path
+   * @param formData - Form data to send
+   * @param params - Optional query parameters
    * @returns The extracted data from the response (without the { status, data } wrapper)
    */
   async postFormData(path, formData, params) {
-    const clientAny = this.client;
-    return clientAny.postFormData(path, formData, params);
+    return this.client.postFormData(path, formData, params);
   }
 };
 
@@ -150,19 +155,24 @@ var LinkResource = class extends BaseResource {
    * Get information about one or more links
    *
    * @param links - Single link or array of links to get info for
+   * @param password - Optional password for password-protected links
    *
    * @example
    * ```ts
-   * const info = await client.link.infos('https://example.com/file.zip')
-   * console.log(info)
+   * const data = await client.link.infos('https://example.com/file.zip')
+   * console.log(data.infos)
+   *
+   * // With password
+   * const protectedData = await client.link.infos(
+   *   'https://example.com/protected.zip',
+   *   'mypassword'
+   * )
    * ```
    */
-  async infos(links) {
+  async infos(links, password) {
     const linksArray = Array.isArray(links) ? links : [links];
-    const data = await this.get("/link/infos", {
-      link: linksArray
-    });
-    return data?.infos;
+    const params = password ? { password } : void 0;
+    return this.post("/link/infos", { "link[]": linksArray }, params);
   }
   /**
    * Extract links from redirectors/link protectors
@@ -171,19 +181,20 @@ var LinkResource = class extends BaseResource {
    *
    * @example
    * ```ts
-   * const links = await client.link.redirector('https://linkprotector.com/abc123')
+   * const data = await client.link.redirector('https://linkprotector.com/abc123')
+   * console.log(data.links)
    * ```
    */
   async redirector(link) {
-    const data = await this.get("/link/redirector", {
+    return this.post("/link/redirector", {
       link
     });
-    return data?.links;
   }
   /**
    * Unlock a download link
    *
    * @param link - The link to unlock
+   * @param password - Optional password for password-protected links
    *
    * @example
    * ```ts
@@ -194,12 +205,17 @@ var LinkResource = class extends BaseResource {
    *   // Handle delayed generation
    *   const delayedResult = await client.link.delayed(result.delayed)
    * }
+   *
+   * // With password
+   * const protectedResult = await client.link.unlock(
+   *   'https://example.com/protected.zip',
+   *   'mypassword'
+   * )
    * ```
    */
-  async unlock(link) {
-    return this.get("/link/unlock", {
-      link
-    });
+  async unlock(link, password) {
+    const params = password ? { password } : void 0;
+    return this.post("/link/unlock", { link }, params);
   }
   /**
    * Unlock a link and automatically poll if delayed
@@ -228,9 +244,10 @@ var LinkResource = class extends BaseResource {
    * const streams = await client.link.streaming('abc123')
    * ```
    */
-  async streaming(id) {
-    return this.get("/link/streaming", {
-      id
+  async streaming(id, stream) {
+    return this.post("/link/streaming", {
+      id,
+      stream
     });
   }
   /**
@@ -244,7 +261,7 @@ var LinkResource = class extends BaseResource {
    * ```
    */
   async delayed(id) {
-    return this.get("/link/delayed", {
+    return this.post("/link/delayed", {
       id
     });
   }
@@ -265,7 +282,7 @@ var MagnetResource = class extends BaseResource {
    */
   async upload(magnets) {
     const magnetsArray = Array.isArray(magnets) ? magnets : [magnets];
-    return this.get("/magnet/upload", {
+    return this.post("/magnet/upload", {
       magnets: magnetsArray
     });
   }
@@ -292,23 +309,22 @@ var MagnetResource = class extends BaseResource {
     return this.postFormData("/magnet/upload/file", formData);
   }
   /**
-   * Get the status of one or more magnets
+   * Get the status of a specific magnet by ID
    *
-   * @param id - Optional magnet ID to get status for a specific magnet
+   * @param id - Magnet ID to get status for
    *
    * @example
    * ```ts
-   * // Get all magnets status
-   * const allStatus = await client.magnet.status()
-   *
-   * // Get specific magnet status
-   * const status = await client.magnet.status('123')
+   * const status = await client.magnet.status(123)
    * console.log(status.magnets[0]?.status) // 'Downloading', 'Ready', etc.
    * ```
+   *
+   * @remarks
+   * This endpoint uses AllDebrid API v4.1 (POST method)
+   * Migrated from v4 GET endpoint which was deprecated on 2024-10-16
    */
   async status(id) {
-    const params = id ? { id } : void 0;
-    const data = await this.get("/magnet/status", params);
+    const data = await this.post("/magnet/status", { id });
     if (data?.magnets && !Array.isArray(data.magnets)) {
       return {
         ...data,
@@ -317,71 +333,215 @@ var MagnetResource = class extends BaseResource {
     }
     return data;
   }
+  /**
+   * Get list of magnets with optional status filter
+   *
+   * @param statusFilter - Optional filter by status: 'active', 'ready', 'expired', or 'error'
+   *
+   * @example
+   * ```ts
+   * // Get all magnets
+   * const allMagnets = await client.magnet.statusList()
+   *
+   * // Get only active magnets
+   * const activeMagnets = await client.magnet.statusList('active')
+   *
+   * // Get only ready magnets
+   * const readyMagnets = await client.magnet.statusList('ready')
+   * ```
+   *
+   * @remarks
+   * This endpoint uses AllDebrid API v4.1 (POST method)
+   */
+  async statusList(statusFilter) {
+    const body = statusFilter ? { status: statusFilter } : void 0;
+    return this.post("/magnet/status", body);
+  }
+  /**
+   * Get magnet status using live mode for bandwidth-optimized delta synchronization
+   *
+   * Live mode is designed for monitoring multiple magnets efficiently by only transmitting
+   * changes between polling intervals, drastically reducing bandwidth usage for dashboards
+   * and real-time monitoring applications.
+   *
+   * ## How it works
+   *
+   * 1. **Session initialization**: Generate a random session ID and start with counter = 0
+   * 2. **First call (fullsync)**: Returns ALL magnets with `fullsync: true`
+   * 3. **Update counter**: Use the `counter` value returned by the API for the next call
+   * 4. **Subsequent calls (delta)**: Returns ONLY magnets that changed since last call
+   * 5. **Repeat**: Keep calling with updated counter to receive only deltas
+   *
+   * ## When to use
+   *
+   * - ✅ Monitoring multiple active magnets simultaneously
+   * - ✅ Building real-time dashboards
+   * - ✅ High-frequency polling scenarios (every few seconds)
+   * - ❌ Watching a single specific magnet (use `watch()` instead)
+   *
+   * ## Important notes
+   *
+   * - **Don't use the `id` parameter**: Passing an ID defeats the purpose of live mode
+   *   as it disables delta sync and behaves like a regular `status()` call
+   * - **Session persistence**: Keep the same session ID for the entire monitoring session
+   * - **Counter tracking**: Always update the counter with the value returned by the API
+   * - **Empty deltas**: When no magnets changed, `magnets` will be an empty array
+   *
+   * @param options - Live mode session options
+   * @param options.session - Unique session ID (generate once: `Math.floor(Math.random() * 1000000)`)
+   * @param options.counter - Sync counter (start at 0, then use value from previous API response)
+   *
+   * @example
+   * ```ts
+   * // Initialize session
+   * const session = Math.floor(Math.random() * 1000000)
+   * let counter = 0
+   *
+   * // First call - returns all magnets (fullsync: true)
+   * const firstCall = await client.magnet.statusLive({ session, counter })
+   * console.log('Full sync:', firstCall.fullsync) // true
+   * console.log('All magnets:', firstCall.magnets) // Array of all magnets
+   * counter = firstCall.counter // Update counter for next call
+   *
+   * // Second call - returns only magnets that changed
+   * await new Promise(resolve => setTimeout(resolve, 3000)) // Wait 3 seconds
+   * const secondCall = await client.magnet.statusLive({ session, counter })
+   * console.log('Delta sync:', secondCall.magnets) // Only changed magnets
+   * counter = secondCall.counter
+   *
+   * // Example: Monitor all magnets until none are active
+   * const activeMagnets = new Map()
+   *
+   * while (true) {
+   *   const response = await client.magnet.statusLive({ session, counter })
+   *   counter = response.counter ?? counter
+   *
+   *   // Update our local state with changes
+   *   if (response.fullsync) {
+   *     activeMagnets.clear()
+   *     response.magnets?.forEach(m => activeMagnets.set(m.id, m))
+   *   } else {
+   *     response.magnets?.forEach(m => {
+   *       if (m.status === 'Ready' || m.status === 'Error' || m.status === 'Expired') {
+   *         activeMagnets.delete(m.id)
+   *       } else {
+   *         activeMagnets.set(m.id, m)
+   *       }
+   *     })
+   *   }
+   *
+   *   // Display current state
+   *   console.log(`Active downloads: ${activeMagnets.size}`)
+   *   activeMagnets.forEach(m => {
+   *     console.log(`  ${m.filename}: ${m.status} - ${m.downloaded}/${m.size} bytes`)
+   *   })
+   *
+   *   // Stop when no more active magnets
+   *   if (activeMagnets.size === 0) {
+   *     console.log('All downloads completed!')
+   *     break
+   *   }
+   *
+   *   await new Promise(resolve => setTimeout(resolve, 3000))
+   * }
+   * ```
+   *
+   * @remarks
+   * This method is ideal for scenarios where you're monitoring multiple magnets and want
+   * to minimize bandwidth. For simple single-magnet monitoring, use `watch()` instead.
+   */
+  async statusLive(options) {
+    const body = {
+      session: options.session,
+      counter: options.counter
+    };
+    return this.post("/magnet/status", body);
+  }
   /**
    * Delete a magnet
    *
-   * @param id - The magnet ID to delete (string)
+   * @param id - The magnet ID to delete
    *
    * @example
    * ```ts
-   * await client.magnet.delete('123')
+   * await client.magnet.delete(123)
    * ```
    */
   async delete(id) {
-    return this.get("/magnet/delete", {
+    return this.post("/magnet/delete", {
       id
     });
   }
   /**
    * Restart one or more failed magnets
    *
-   * @param ids - Single magnet ID or array of magnet IDs to restart (strings)
+   * @param ids - Single magnet ID or array of magnet IDs to restart (numbers)
    *
    * @example
    * ```ts
    * // Restart single magnet
-   * await client.magnet.restart('123')
+   * await client.magnet.restart(123)
    *
    * // Restart multiple magnets
-   * await client.magnet.restart(['123', '456'])
+   * await client.magnet.restart([123, 456])
    * ```
    */
   async restart(ids) {
     const idsArray = Array.isArray(ids) ? ids : [ids];
-    return this.get("/magnet/restart", {
+    return this.post("/magnet/restart", {
       ids: idsArray
     });
   }
   /**
-   * Check instant availability of magnets
+   * Get files for a completed magnet
    *
-   * @param magnets - Single magnet hash or array of hashes
+   * @param ids - The magnet ID or IDs to get files for
    *
    * @example
    * ```ts
-   * const available = await client.magnet.instant(['hash1', 'hash2'])
-   * console.log(available.magnets)
+   * const data = await client.magnet.files(123)
+   * data?.magnets?.forEach(magnet => {
+   *   console.log(magnet.filename, magnet.files)
+   * })
    * ```
+   *
+   * @remarks
+   * Files are now retrieved separately from magnet status (since v4.1)
+   * Only available for magnets with status 'Ready'
    */
-  async instant(magnets) {
-    const magnetsArray = Array.isArray(magnets) ? magnets : [magnets];
-    return this.get("/magnet/instant", {
-      magnets: magnetsArray
-    });
+  async files(ids) {
+    const formData = new FormData();
+    const idsArray = Array.isArray(ids) ? ids : [ids];
+    for (const id of idsArray) {
+      formData.append("id[]", String(id));
+    }
+    return this.postFormData("/magnet/files", formData);
   }
   /**
    * Watch a magnet's status with automatic polling
    *
-   * @param id - The magnet ID to watch (string)
+   * This is a simple helper that polls the status of a specific magnet until it reaches
+   * a target status (default: 'Ready'). For advanced use cases with multiple magnets
+   * or bandwidth optimization, use `statusLive()` directly instead.
+   *
+   * @param id - The magnet ID to watch
    * @param options - Watch options
+   * @param options.interval - Polling interval in milliseconds (default: 3000)
+   * @param options.maxAttempts - Maximum polling attempts, 0 for infinite (default: 0)
+   * @param options.onUpdate - Callback called on each status update
+   * @param options.stopOnStatus - Stop when magnet reaches this status (default: 'Ready')
    *
    * @example
    * ```ts
-   * await client.magnet.watch('123', {
+   * await client.magnet.watch(123, {
    *   onUpdate: (status) => console.log('Status:', status.magnets[0]?.status),
    *   stopOnStatus: 'Ready'
    * })
    * ```
+   *
+   * @remarks
+   * For monitoring multiple magnets efficiently, use `statusLive()` directly.
+   * See the `statusLive()` documentation for details on delta synchronization.
    */
   async watch(id, options = {}) {
     const { interval = 3e3, maxAttempts = 0, onUpdate, stopOnStatus = "Ready" } = options;
@@ -402,6 +562,111 @@ var MagnetResource = class extends BaseResource {
   }
 };
 
+// src/resources/pin.ts
+var PinResource = class extends BaseResource {
+  /**
+   * Generate a new PIN code for authentication
+   *
+   * This initiates the PIN authentication flow. The user should visit the
+   * returned URL to authorize the application.
+   *
+   * @example
+   * ```ts
+   * const pinData = await client.pin.generate()
+   * console.log('Visit:', pinData.user_url)
+   * console.log('PIN:', pinData.pin)
+   *
+   * // Poll the check endpoint until user authorizes
+   * const auth = await client.pin.check(pinData.check, pinData.pin)
+   * if (auth.activated) {
+   *   console.log('API Key:', auth.apikey)
+   * }
+   * ```
+   *
+   * @returns PIN code and authorization URL
+   */
+  async generate() {
+    return super.get("/pin/get");
+  }
+  /**
+   * Check the status of a PIN authentication
+   *
+   * Poll this endpoint to check if the user has authorized the application.
+   * Once authorized, the response will include the API key.
+   *
+   * @param check - Check ID from /pin/get
+   * @param pin - PIN code from /pin/get
+   *
+   * @example
+   * ```ts
+   * const pinData = await client.pin.generate()
+   *
+   * // Poll every few seconds until activated
+   * const checkStatus = async () => {
+   *   const result = await client.pin.check(pinData.check, pinData.pin)
+   *   if (result?.activated && result?.apikey) {
+   *     console.log('Authorized! API Key:', result.apikey)
+   *     return result.apikey
+   *   }
+   *   // Wait and try again
+   *   await new Promise(resolve => setTimeout(resolve, 3000))
+   *   return checkStatus()
+   * }
+   *
+   * const apikey = await checkStatus()
+   * ```
+   *
+   * @returns Authorization status and API key (if activated)
+   */
+  async check(check, pin) {
+    return super.get("/pin/check", { check, pin });
+  }
+  /**
+   * Helper method to wait for PIN authorization with automatic polling
+   *
+   * This method handles the polling logic for you, making it easier to
+   * implement the PIN authentication flow.
+   *
+   * @param check - Check ID from /pin/get
+   * @param pin - PIN code from /pin/get
+   * @param options - Polling options
+   * @param options.timeout - Maximum time to wait in milliseconds (default: 600000 = 10 minutes)
+   * @param options.interval - Polling interval in milliseconds (default: 3000 = 3 seconds)
+   *
+   * @example
+   * ```ts
+   * const pinData = await client.pin.generate()
+   * console.log('Visit:', pinData.user_url)
+   *
+   * try {
+   *   const apikey = await client.pin.waitForAuth(pinData.check, pinData.pin, {
+   *     timeout: 600000, // 10 minutes
+   *     interval: 3000,  // Check every 3 seconds
+   *   })
+   *   console.log('Authorized! API Key:', apikey)
+   * } catch (error) {
+   *   console.error('Authorization timed out or failed')
+   * }
+   * ```
+   *
+   * @returns The API key once authorized
+   * @throws Error if timeout is reached or authorization fails
+   */
+  async waitForAuth(check, pin, options = {}) {
+    const timeout = options.timeout ?? 6e5;
+    const interval = options.interval ?? 3e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const result = await this.check(check, pin);
+      if (result?.activated && result?.apikey) {
+        return result.apikey;
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error("PIN authorization timeout - user did not authorize within the time limit");
+  }
+};
+
 // src/resources/user.ts
 var UserResource = class extends BaseResource {
   /**
@@ -409,13 +674,12 @@ var UserResource = class extends BaseResource {
    *
    * @example
    * ```ts
-   * const user = await client.user.getInfo()
-   * console.log(user.username, user.isPremium)
+   * const data = await client.user.getInfo()
+   * console.log(data.user.username, data.user.isPremium)
    * ```
    */
   async getInfo() {
-    const data = await this.get("/user");
-    return data?.user;
+    return this.get("/user");
   }
   /**
    * Get available hosts for the current user based on their subscription
@@ -443,7 +707,7 @@ var UserResource = class extends BaseResource {
    * ```
    */
   async clearNotification(code) {
-    await this.get("/user/notification/clear", { code });
+    await this.post("/user/notification/clear", { code });
   }
   // ============================================
   // Saved Links Management
@@ -461,30 +725,60 @@ var UserResource = class extends BaseResource {
     return this.get("/user/links");
   }
   /**
-   * Save a link for later use
+   * Save one or multiple links for later use
    *
-   * @param link - The link to save
+   * Supports batch operations - you can save multiple links in a single request.
+   *
+   * @param links - Single link or array of links to save
    *
    * @example
    * ```ts
+   * // Save single link
    * await client.user.saveLink('https://example.com/file.zip')
+   *
+   * // Save multiple links at once
+   * await client.user.saveLink([
+   *   'https://example.com/file1.zip',
+   *   'https://example.com/file2.zip',
+   *   'https://example.com/file3.zip'
+   * ])
    * ```
    */
-  async saveLink(link) {
-    return this.get("/user/links/save", { link });
+  async saveLink(links) {
+    const linksArray = Array.isArray(links) ? links : [links];
+    const formData = new FormData();
+    for (const link of linksArray) {
+      formData.append("links[]", link);
+    }
+    return this.postFormData("/user/links/save", formData);
   }
   /**
-   * Delete a saved link
+   * Delete one or multiple saved links
    *
-   * @param link - The link to delete (can be the saved link ID or URL)
+   * Supports batch operations - you can delete multiple links in a single request.
+   *
+   * @param links - Single link or array of links to delete (can be saved link IDs or URLs)
    *
    * @example
    * ```ts
+   * // Delete single link
    * await client.user.deleteLink('saved-link-id')
+   *
+   * // Delete multiple links at once
+   * await client.user.deleteLink([
+   *   'saved-link-id-1',
+   *   'saved-link-id-2',
+   *   'saved-link-id-3'
+   * ])
    * ```
    */
-  async deleteLink(link) {
-    return this.get("/user/links/delete", { link });
+  async deleteLink(links) {
+    const linksArray = Array.isArray(links) ? links : [links];
+    const formData = new FormData();
+    for (const link of linksArray) {
+      formData.append("links[]", link);
+    }
+    return this.postFormData("/user/links/delete", formData);
   }
   // ============================================
   // History Management
@@ -510,12 +804,114 @@ var UserResource = class extends BaseResource {
    * ```
    */
   async clearHistory() {
-    return this.get("/user/history/delete");
+    return this.post("/user/history/delete");
+  }
+  // ============================================
+  // Email Verification
+  // ============================================
+  /**
+   * Check email verification status
+   *
+   * @param token - Verification token
+   *
+   * @example
+   * ```ts
+   * const status = await client.user.getVerificationStatus('verification-token')
+   * console.log(status.verif) // 'waiting', 'allowed', or 'denied'
+   * ```
+   */
+  async getVerificationStatus(token) {
+    return this.post("/user/verif", void 0, { token });
+  }
+  /**
+   * Resend verification email
+   *
+   * @param token - Verification token
+   *
+   * @example
+   * ```ts
+   * await client.user.resendVerification('verification-token')
+   * ```
+   */
+  async resendVerification(token) {
+    return this.post("/user/verif/resend", void 0, { token });
+  }
+};
+
+// src/resources/voucher.ts
+var VoucherResource = class extends BaseResource {
+  /**
+   * Get voucher balance for reseller accounts
+   *
+   * This endpoint allows resellers to check their remaining voucher balance.
+   * Only available for accounts with reseller privileges.
+   *
+   * @example
+   * ```ts
+   * const balance = await client.voucher.getBalance()
+   * console.log('Remaining balance:', balance.balance, '€')
+   * ```
+   *
+   * @returns Voucher balance information
+   */
+  async getBalance() {
+    return this.get("/voucher/balance");
+  }
+  /**
+   * Retrieve existing vouchers from reseller inventory
+   *
+   * This endpoint retrieves vouchers that were previously generated
+   * and are available in your inventory.
+   *
+   * @param quantity - Optional number of vouchers to retrieve
+   *
+   * @example
+   * ```ts
+   * // Get all available vouchers
+   * const allVouchers = await client.voucher.getVouchers()
+   * console.log('Vouchers:', allVouchers?.codes)
+   *
+   * // Get specific quantity
+   * const fiveVouchers = await client.voucher.getVouchers(5)
+   * ```
+   *
+   * @returns List of voucher codes
+   */
+  async getVouchers(quantity) {
+    const params = quantity ? { quantity } : void 0;
+    return this.get("/voucher/get", params);
+  }
+  /**
+   * Generate new vouchers (deducts from reseller balance)
+   *
+   * This endpoint creates new vouchers and deducts the cost from your
+   * reseller account balance.
+   *
+   * @param quantity - Number of vouchers to generate
+   * @param duration - Voucher duration in days
+   *
+   * @example
+   * ```ts
+   * // Generate 10 vouchers valid for 30 days
+   * const vouchers = await client.voucher.generateVouchers(10, 30)
+   * console.log('Generated vouchers:', vouchers?.codes)
+   *
+   * // Generate 5 vouchers valid for 7 days
+   * const weekVouchers = await client.voucher.generateVouchers(5, 7)
+   * ```
+   *
+   * @returns List of newly generated voucher codes
+   */
+  async generateVouchers(quantity, duration) {
+    return this.post("/voucher/generate", {
+      quantity,
+      duration
+    });
   }
 };
 
 // src/client.ts
-var DEFAULT_BASE_URL = "https://api.alldebrid.com/v4";
+var DEFAULT_BASE_URL = "https://api.alldebrid.com/v4.1";
 var DEFAULT_AGENT = "@alldebrid/sdk";
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_MAX_RETRIES = 3;
@@ -537,6 +933,14 @@ var AllDebridClient = class {
    * Host resource for getting information about supported hosts
    */
   host;
+  /**
+   * Pin resource for PIN-based authentication
+   */
+  pin;
+  /**
+   * Voucher resource for reseller voucher management
+   */
+  voucher;
   constructor(config) {
     this.config = {
       apiKey: config.apiKey,
@@ -550,6 +954,8 @@ var AllDebridClient = class {
     this.link = new LinkResource(this);
     this.magnet = new MagnetResource(this);
     this.host = new HostResource(this);
+    this.pin = new PinResource(this);
+    this.voucher = new VoucherResource(this);
   }
   /**
    * Build query string from params
@@ -574,8 +980,11 @@ var AllDebridClient = class {
   }
   /**
    * Make a GET request
-   * @param T - The generated response type (e.g., GetLinkUnlockResponse)
+   * @template T - The generated response type (e.g., GetLinkUnlockResponse)
+   * @param path - API endpoint path
+   * @param params - Optional query parameters
    * @returns The extracted data from the response (without the { status, data } wrapper)
+   * @internal
    */
   async get(path, params) {
     try {
@@ -602,14 +1011,30 @@ var AllDebridClient = class {
     }
   }
   /**
-   * Make a POST request
-   * @param T - The generated response type
+   * Make a POST request with application/x-www-form-urlencoded
+   * @template T - The generated response type
+   * @param path - API endpoint path
+   * @param body - Request body (will be converted to URLSearchParams)
+   * @param params - Optional query parameters
    * @returns The extracted data from the response (without the { status, data } wrapper)
+   * @internal
    */
   async post(path, body, params) {
     try {
       const url = this.buildUrl(path, params);
-      const json = await wretch__default.default(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).post(body).json();
+      const formData = new URLSearchParams();
+      if (body && typeof body === "object") {
+        for (const [key, value] of Object.entries(body)) {
+          if (value !== void 0 && value !== null) {
+            if (Array.isArray(value)) {
+              value.forEach((v) => formData.append(key, String(v)));
+            } else {
+              formData.append(key, String(value));
+            }
+          }
+        }
+      }
+      const json = await wretch__default.default(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).body(formData).post().json();
       if (json.status === "error" && json.error) {
         throw createTypedError(json.error.code, json.error.message);
       }
@@ -632,8 +1057,12 @@ var AllDebridClient = class {
   }
   /**
    * Make a POST request with FormData (multipart/form-data)
-   * @param T - The generated response type
+   * @template T - The generated response type
+   * @param path - API endpoint path
+   * @param formData - Form data to send
+   * @param params - Optional query parameters
    * @returns The extracted data from the response (without the { status, data } wrapper)
+   * @internal
    */
   async postFormData(path, formData, params) {
     try {
@@ -661,14 +1090,20 @@ var AllDebridClient = class {
   }
   /**
    * Test the API connection
+   *
+   * This endpoint doesn't require authentication and can be used to verify
+   * that the AllDebrid API is reachable.
+   *
+   * @example
+   * ```ts
+   * const result = await client.ping()
+   * console.log(result.ping) // 'pong'
+   * ```
+   *
+   * @returns Ping response with 'pong' message
    */
   async ping() {
-    try {
-      await this.get("/user");
-      return true;
-    } catch {
-      return false;
-    }
+    return this.get("/ping");
   }
 };
 
@@ -681,7 +1116,9 @@ exports.LinkResource = LinkResource;
 exports.MagnetError = MagnetError;
 exports.MagnetResource = MagnetResource;
 exports.NetworkError = NetworkError;
+exports.PinResource = PinResource;
 exports.UserResource = UserResource;
+exports.VoucherResource = VoucherResource;
 exports.createTypedError = createTypedError;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map