@adbjs/sdk 0.1.1 → 1.0.0

package/dist/index.js

@@ -66,30 +66,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);
   }
 };
 
@@ -144,18 +149,28 @@ 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)
+   *
+   * // With password
+   * const protectedInfo = 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
-    });
+    const params = password ? { password } : void 0;
+    const data = await this.post(
+      "/link/infos",
+      { "link[]": linksArray },
+      params
+    );
     return data?.infos;
   }
   /**
@@ -169,7 +184,7 @@ var LinkResource = class extends BaseResource {
    * ```
    */
   async redirector(link) {
-    const data = await this.get("/link/redirector", {
+    const data = await this.post("/link/redirector", {
       link
     });
     return data?.links;
@@ -178,6 +193,7 @@ var LinkResource = class extends BaseResource {
    * Unlock a download link
    *
    * @param link - The link to unlock
+   * @param password - Optional password for password-protected links
    *
    * @example
    * ```ts
@@ -188,12 +204,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
@@ -222,9 +243,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
     });
   }
   /**
@@ -238,7 +260,7 @@ var LinkResource = class extends BaseResource {
    * ```
    */
   async delayed(id) {
-    return this.get("/link/delayed", {
+    return this.post("/link/delayed", {
       id
     });
   }
@@ -259,7 +281,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
     });
   }
@@ -286,23 +308,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,
@@ -311,78 +332,186 @@ 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 reduced bandwidth consumption
+   *
+   * Live mode uses delta synchronization - only changes since the last call are transmitted.
+   * On the first call (counter=0), all data is returned with `fullsync: true`.
+   * Subsequent calls return only modifications.
+   *
+   * @param options - Live mode options
+   * @param options.session - Session ID (generate once per session and reuse)
+   * @param options.counter - Synchronization counter (start at 0, use returned counter for next call)
+   * @param id - Optional magnet ID to filter a specific magnet
+   *
+   * @example
+   * ```ts
+   * // Initialize session
+   * const session = Math.floor(Math.random() * 1000000)
+   * let counter = 0
+   *
+   * // First call - full sync
+   * const firstCall = await client.magnet.statusLive({ session, counter })
+   * console.log('Full sync:', firstCall.fullsync) // true
+   * console.log('All magnets:', firstCall.magnets)
+   *
+   * // Update counter with value returned by API
+   * counter = firstCall.counter
+   *
+   * // Second call - only changes
+   * const secondCall = await client.magnet.statusLive({ session, counter })
+   * console.log('Delta sync:', secondCall.magnets) // Only modified magnets
+   *
+   * // Filter specific magnet in live mode
+   * const magnetLive = await client.magnet.statusLive({ session, counter }, 123)
+   * ```
+   *
+   * @remarks
+   * This is ideal for real-time dashboards or frequent polling scenarios
+   * as it significantly reduces bandwidth usage by transmitting only changes.
+   */
+  async statusLive(options, id) {
+    const body = {
+      session: options.session,
+      counter: options.counter
+    };
+    if (id !== void 0) {
+      body.id = id;
+    }
+    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 files = await client.magnet.files(123)
+   * files?.forEach(file => {
+   *   console.log(file.filename, file.link)
+   * })
    * ```
+   *
+   * @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));
+    }
+    const data = await this.postFormData("/magnet/files", formData);
+    return data?.magnets;
   }
   /**
    * Watch a magnet's status with automatic polling
    *
-   * @param id - The magnet ID to watch (string)
+   * @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')
+   * @param options.useLiveMode - Use live mode for reduced bandwidth (default: false)
    *
    * @example
    * ```ts
-   * await client.magnet.watch('123', {
+   * // Standard mode
+   * await client.magnet.watch(123, {
    *   onUpdate: (status) => console.log('Status:', status.magnets[0]?.status),
    *   stopOnStatus: 'Ready'
    * })
+   *
+   * // Live mode for reduced bandwidth
+   * await client.magnet.watch(123, {
+   *   useLiveMode: true,
+   *   interval: 2000,
+   *   onUpdate: (status) => console.log('Update:', status)
+   * })
    * ```
    */
   async watch(id, options = {}) {
-    const { interval = 3e3, maxAttempts = 0, onUpdate, stopOnStatus = "Ready" } = options;
+    const {
+      interval = 3e3,
+      maxAttempts = 0,
+      onUpdate,
+      stopOnStatus = "Ready",
+      useLiveMode = false
+    } = options;
     let attempt = 0;
+    let session;
+    let counter = 0;
+    if (useLiveMode) {
+      session = Math.floor(Math.random() * 1e6);
+    }
     while (maxAttempts === 0 || attempt < maxAttempts) {
       attempt++;
-      const status = await this.status(id);
+      const status = useLiveMode && session !== void 0 ? await this.statusLive({ session, counter }, id) : await this.status(id);
+      if (useLiveMode && status?.counter !== void 0) {
+        counter = status.counter;
+      }
       onUpdate?.(status);
       const magnet = status?.magnets?.[0];
       if (magnet?.status === stopOnStatus) {
@@ -396,6 +525,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 {
   /**
@@ -437,7 +671,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
@@ -455,30 +689,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
+   *
+   * Supports batch operations - you can save multiple links in a single request.
    *
-   * @param link - The link to save
+   * @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
+   *
+   * Supports batch operations - you can delete multiple links in a single request.
    *
-   * @param link - The link to delete (can be the saved link ID or URL)
+   * @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
@@ -504,12 +768,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;
@@ -531,6 +897,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,
@@ -544,6 +918,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
@@ -568,8 +944,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 {
@@ -596,14 +975,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(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(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);
       }
@@ -626,8 +1021,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 {
@@ -655,17 +1054,23 @@ 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");
   }
 };
 
-export { AllDebridClient, AllDebridError, AuthenticationError, HostResource, LinkError, LinkResource, MagnetError, MagnetResource, NetworkError, UserResource, createTypedError };
+export { AllDebridClient, AllDebridError, AuthenticationError, HostResource, LinkError, LinkResource, MagnetError, MagnetResource, NetworkError, PinResource, UserResource, VoucherResource, createTypedError };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map