@adbjs/sdk 2.0.2 → 2.1.1

package/dist/index.js

@@ -1,9 +1,252 @@
-import wretch from 'wretch';
+// ../../node_modules/.bun/wretch@3.0.6/node_modules/wretch/dist/utils.js
+function extractContentType(headers = {}) {
+  const normalizedHeaders = headers instanceof Array ? Object.fromEntries(headers) : headers;
+  for (const k in normalizedHeaders) {
+    if (k.toLowerCase() === "content-type")
+      return normalizedHeaders[k];
+  }
+}
+function isLikelyJsonMime(value) {
+  return /^application\/.*json/.test(value);
+}
+var mix = (one, two, mergeArrays = false) => {
+  const acc = { ...one };
+  for (const key in two) {
+    if (!Object.prototype.hasOwnProperty.call(two, key))
+      continue;
+    const value = one[key];
+    const newValue = two[key];
+    acc[key] = Array.isArray(value) && Array.isArray(newValue) ? mergeArrays ? [...value, ...newValue] : newValue : typeof value === "object" && typeof newValue === "object" ? mix(value, newValue, mergeArrays) : newValue;
+  }
+  return acc;
+};
 
-// src/client.ts
+// ../../node_modules/.bun/wretch@3.0.6/node_modules/wretch/dist/constants.js
+var JSON_MIME = "application/json";
+var FETCH_ERROR = Symbol();
+var CATCHER_FALLBACK = Symbol();
+
+// ../../node_modules/.bun/wretch@3.0.6/node_modules/wretch/dist/middleware.js
+var middlewareHelper = (middlewares) => (fetchFunction) => middlewares.reduceRight((acc, curr) => curr(acc), fetchFunction);
+
+// ../../node_modules/.bun/wretch@3.0.6/node_modules/wretch/dist/resolver.js
+class WretchError extends Error {
+}
+var resolver = (wretch) => {
+  const sharedState = Object.create(null);
+  wretch = wretch._addons.reduce((w, addon) => addon.beforeRequest && addon.beforeRequest(w, wretch._options, sharedState) || w, wretch);
+  const { _url: url, _options: opts, _fetch: customFetch, _errorTransformer: errorTransformer, _catchers, _resolvers: resolvers, _middlewares: middlewares, _addons: addons } = wretch;
+  const catchers = new Map(_catchers);
+  const finalOptions = opts;
+  let finalUrl = url;
+  const _fetchReq = middlewareHelper(middlewares)((url2, options) => {
+    finalUrl = url2;
+    const fetchImpl = customFetch || fetch;
+    return fetchImpl(url2, options);
+  })(url, finalOptions);
+  const referenceError = new Error;
+  const throwingPromise = _fetchReq.then(async (response) => {
+    if (!response.ok) {
+      const err = new WretchError;
+      err["cause"] = referenceError;
+      err.stack += `
+CAUSE: ` + referenceError.stack;
+      err.response = response;
+      err.status = response.status;
+      err.url = finalUrl;
+      if (response.type === "opaque" || errorTransformer) {
+        err.message = response.statusText;
+      } else {
+        try {
+          err.message = await response.clone().text();
+        } catch (_a) {
+          err.message = response.statusText;
+        }
+      }
+      throw err;
+    }
+    return response;
+  });
+  const catchersWrapper = (promise) => promise.catch(async (error) => {
+    const catcher = catchers.get(error === null || error === undefined ? undefined : error.status) || catchers.get(error === null || error === undefined ? undefined : error.name) || !(error instanceof WretchError) && catchers.get(FETCH_ERROR) || catchers.get(CATCHER_FALLBACK);
+    if (error.response && errorTransformer) {
+      error = await errorTransformer(error, error.response, wretch);
+    }
+    if (catcher)
+      return catcher(error, wretch);
+    throw error;
+  });
+  const bodyParser = (funName) => (cb) => {
+    const promise = funName ? throwingPromise.then((_) => _ === null || _ === undefined ? undefined : _[funName]()) : throwingPromise;
+    return catchersWrapper(cb ? promise.then(cb) : promise);
+  };
+  const responseChain = {
+    _wretchReq: wretch,
+    _fetchReq,
+    _sharedState: sharedState,
+    res: bodyParser(null),
+    json: bodyParser("json"),
+    blob: bodyParser("blob"),
+    formData: bodyParser("formData"),
+    arrayBuffer: bodyParser("arrayBuffer"),
+    text: bodyParser("text"),
+    error(errorId, cb) {
+      catchers.set(errorId, cb);
+      return this;
+    },
+    badRequest(cb) {
+      return this.error(400, cb);
+    },
+    unauthorized(cb) {
+      return this.error(401, cb);
+    },
+    forbidden(cb) {
+      return this.error(403, cb);
+    },
+    notFound(cb) {
+      return this.error(404, cb);
+    },
+    timeout(cb) {
+      return this.error(408, cb);
+    },
+    internalError(cb) {
+      return this.error(500, cb);
+    },
+    fetchError(cb) {
+      return this.error(FETCH_ERROR, cb);
+    }
+  };
+  const enhancedResponseChain = addons.reduce((chain, addon) => ({
+    ...chain,
+    ...typeof addon.resolver === "function" ? addon.resolver(chain) : addon.resolver
+  }), responseChain);
+  return resolvers.reduce((chain, r) => r(chain, wretch), enhancedResponseChain);
+};
+
+// ../../node_modules/.bun/wretch@3.0.6/node_modules/wretch/dist/core.js
+var core = {
+  _url: "",
+  _options: {},
+  _catchers: new Map,
+  _resolvers: [],
+  _deferred: [],
+  _middlewares: [],
+  _addons: [],
+  addon(addon) {
+    const addons = Array.isArray(addon) ? addon : [addon];
+    const wretchProps = addons.reduce((acc, a) => ({ ...acc, ...a.wretch }), {});
+    return { ...this, _addons: [...this._addons, ...addons], ...wretchProps };
+  },
+  fetchPolyfill(fetchImpl) {
+    return { ...this, _fetch: fetchImpl };
+  },
+  url(_url, replace = false) {
+    if (replace)
+      return { ...this, _url };
+    const idx = this._url.indexOf("?");
+    return {
+      ...this,
+      _url: idx > -1 ? this._url.slice(0, idx) + _url + this._url.slice(idx) : this._url + _url
+    };
+  },
+  options(options, replace = false) {
+    return { ...this, _options: replace ? options : mix(this._options, options) };
+  },
+  headers(headerValues) {
+    const headers = !headerValues ? {} : Array.isArray(headerValues) ? Object.fromEntries(headerValues) : ("entries" in headerValues) ? Object.fromEntries(headerValues.entries()) : headerValues;
+    return { ...this, _options: mix(this._options, { headers }) };
+  },
+  accept(headerValue) {
+    return this.headers({ Accept: headerValue });
+  },
+  content(headerValue) {
+    return this.headers({ "Content-Type": headerValue });
+  },
+  auth(headerValue) {
+    return this.headers({ Authorization: headerValue });
+  },
+  catcher(errorId, catcher) {
+    const newMap = new Map(this._catchers);
+    newMap.set(errorId, catcher);
+    return { ...this, _catchers: newMap };
+  },
+  catcherFallback(catcher) {
+    return this.catcher(CATCHER_FALLBACK, catcher);
+  },
+  customError(transformer) {
+    return { ...this, _errorTransformer: transformer };
+  },
+  resolve(resolver2, clear = false) {
+    return { ...this, _resolvers: clear ? [resolver2] : [...this._resolvers, resolver2] };
+  },
+  defer(callback, clear = false) {
+    return {
+      ...this,
+      _deferred: clear ? [callback] : [...this._deferred, callback]
+    };
+  },
+  middlewares(middlewares, clear = false) {
+    return {
+      ...this,
+      _middlewares: clear ? middlewares : [...this._middlewares, ...middlewares]
+    };
+  },
+  fetch(method = this._options.method, url = "", body = null) {
+    let base = this.url(url).options({ method });
+    const contentType = extractContentType(base._options.headers);
+    const jsonify = typeof body === "object" && !(body instanceof FormData) && (!base._options.headers || !contentType || isLikelyJsonMime(contentType));
+    base = !body ? base : jsonify ? base.json(body, contentType) : base.body(body);
+    return resolver(base._deferred.reduce((acc, curr) => curr(acc, acc._url, acc._options), base));
+  },
+  get(url = "") {
+    return this.fetch("GET", url);
+  },
+  delete(url = "") {
+    return this.fetch("DELETE", url);
+  },
+  put(body, url = "") {
+    return this.fetch("PUT", url, body);
+  },
+  post(body, url = "") {
+    return this.fetch("POST", url, body);
+  },
+  patch(body, url = "") {
+    return this.fetch("PATCH", url, body);
+  },
+  head(url = "") {
+    return this.fetch("HEAD", url);
+  },
+  opts(url = "") {
+    return this.fetch("OPTIONS", url);
+  },
+  body(contents) {
+    return { ...this, _options: { ...this._options, body: contents } };
+  },
+  json(jsObject, contentType) {
+    const currentContentType = extractContentType(this._options.headers);
+    return this.content(contentType || isLikelyJsonMime(currentContentType) && currentContentType || JSON_MIME).body(JSON.stringify(jsObject));
+  },
+  toFetch() {
+    return (fetchUrl, fetchOptions = {}) => {
+      return this.url(fetchUrl).options(fetchOptions).catcherFallback((error) => {
+        if (error instanceof WretchError) {
+          return error.response;
+        } else {
+          throw error;
+        }
+      }).fetch().res();
+    };
+  }
+};
+
+// ../../node_modules/.bun/wretch@3.0.6/node_modules/wretch/dist/index.js
+var factory = (_url = "", _options = {}) => ({ ...core, _url, _options });
+factory["default"] = factory;
+factory.WretchError = WretchError;
+var dist_default = factory;
 
 // src/errors.ts
-var AllDebridError = class _AllDebridError extends Error {
+class AllDebridError extends Error {
   code;
   isAllDebridError = true;
   constructor(code, message) {
@@ -11,41 +254,43 @@ var AllDebridError = class _AllDebridError extends Error {
     this.name = "AllDebridError";
     this.code = code;
     if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, _AllDebridError);
+      Error.captureStackTrace(this, AllDebridError);
     }
   }
-  /**
-   * Create an AllDebridError from an API error response
-   */
   static fromApiError(error) {
-    return new _AllDebridError(error.code, error.message);
+    return new AllDebridError(error.code, error.message);
   }
-};
-var AuthenticationError = class extends AllDebridError {
+}
+
+class AuthenticationError extends AllDebridError {
   constructor(code, message) {
     super(code, message);
     this.name = "AuthenticationError";
   }
-};
-var LinkError = class extends AllDebridError {
+}
+
+class LinkError extends AllDebridError {
   constructor(code, message) {
     super(code, message);
     this.name = "LinkError";
   }
-};
-var MagnetError = class extends AllDebridError {
+}
+
+class MagnetError extends AllDebridError {
   constructor(code, message) {
     super(code, message);
     this.name = "MagnetError";
   }
-};
-var NetworkError = class extends AllDebridError {
+}
+
+class NetworkError extends AllDebridError {
+  statusCode;
   constructor(message, statusCode) {
     super("NETWORK_ERROR", message);
     this.statusCode = statusCode;
     this.name = "NetworkError";
   }
-};
+}
 function createTypedError(code, message) {
   if (code.startsWith("AUTH_")) {
     return new AuthenticationError(code, message);
@@ -60,263 +305,82 @@ function createTypedError(code, message) {
 }
 
 // src/base-resource.ts
-var BaseResource = class {
+class BaseResource {
+  client;
   constructor(client) {
     this.client = client;
   }
-  /**
-   * Make a GET request
-   * @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) {
     return this.client.get(path, params);
   }
-  /**
-   * Make a POST request
-   * @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) {
     return this.client.post(path, body, params);
   }
-  /**
-   * Make a POST request with FormData (multipart/form-data)
-   * @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) {
     return this.client.postFormData(path, formData, params);
   }
-};
+}
 
 // src/resources/host.ts
-var HostResource = class extends BaseResource {
-  /**
-   * Get list of all supported hosts with their information
-   *
-   * @param hostOnly - If true, only return hosts (exclude streams and redirectors)
-   *
-   * @example
-   * ```ts
-   * const hosts = await client.host.list()
-   * console.log(hosts.hosts) // All supported file hosts
-   * console.log(hosts.streams) // Streaming hosts
-   * console.log(hosts.redirectors) // Link redirectors
-   * ```
-   */
+class HostResource extends BaseResource {
   async list(hostOnly) {
-    const params = hostOnly ? { hostOnly: "1" } : void 0;
+    const params = hostOnly ? { hostOnly: "1" } : undefined;
     return this.get("/hosts", params);
   }
-  /**
-   * Get array of all supported domain names
-   *
-   * @example
-   * ```ts
-   * const domains = await client.host.domains()
-   * console.log(domains) // ['rapidgator.net', 'uploaded.net', ...]
-   * ```
-   */
   async domains() {
     return this.get("/hosts/domains");
   }
-  /**
-   * Get hosts ordered by restriction level (priority list)
-   *
-   * @example
-   * ```ts
-   * const priority = await client.host.priority()
-   * console.log(priority.hosts) // Ordered list with restriction levels
-   * ```
-   */
   async priority() {
     return this.get("/hosts/priority");
   }
-};
+}
 
 // src/resources/link.ts
-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 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'
-   * )
-   * ```
-   */
+class LinkResource extends BaseResource {
   async infos(links, password) {
     const linksArray = Array.isArray(links) ? links : [links];
-    const params = password ? { password } : void 0;
+    const params = password ? { password } : undefined;
     return this.post("/link/infos", { "link[]": linksArray }, params);
   }
-  /**
-   * Extract links from redirectors/link protectors
-   *
-   * @param link - The redirector link to extract from
-   *
-   * @example
-   * ```ts
-   * const data = await client.link.redirector('https://linkprotector.com/abc123')
-   * console.log(data.links)
-   * ```
-   */
   async redirector(link) {
     return this.post("/link/redirector", {
       link
     });
   }
-  /**
-   * Unlock a download link
-   *
-   * @param link - The link to unlock
-   * @param password - Optional password for password-protected links
-   *
-   * @example
-   * ```ts
-   * const result = await client.link.unlock('https://example.com/file.zip')
-   * if (result.link) {
-   *   console.log('Direct link:', result.link)
-   * } else if (result.delayed) {
-   *   // 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, password) {
-    const params = password ? { password } : void 0;
+    const params = password ? { password } : undefined;
     return this.post("/link/unlock", { link }, params);
   }
-  /**
-   * Unlock a link and automatically poll if delayed
-   * Note: The API response format doesn't include a delayed field in the current OpenAPI spec.
-   * This method will be updated once the delayed mechanism is documented.
-   *
-   * @param link - The link to unlock
-   * @param _options - Polling options (currently unused)
-   *
-   * @example
-   * ```ts
-   * const result = await client.link.unlockWithPolling('https://example.com/file.zip')
-   * console.log('Direct link:', result.link)
-   * ```
-   */
   async unlockWithPolling(link, _options = {}) {
     return this.unlock(link);
   }
-  /**
-   * Get streaming options for a generated link
-   *
-   * @param id - The generated link ID or streaming ID
-   *
-   * @example
-   * ```ts
-   * const streams = await client.link.streaming('abc123')
-   * ```
-   */
   async streaming(id, stream) {
     return this.post("/link/streaming", {
       id,
       stream
     });
   }
-  /**
-   * Get the status/result of a delayed link generation
-   *
-   * @param id - The delayed generation ID
-   *
-   * @example
-   * ```ts
-   * const result = await client.link.delayed('delayed_id_123')
-   * ```
-   */
   async delayed(id) {
     return this.post("/link/delayed", {
       id
     });
   }
-};
+}
 
 // src/resources/magnet.ts
-var MagnetResource = class extends BaseResource {
-  /**
-   * Upload magnets by URI or hash
-   *
-   * @param magnets - Single magnet URI/hash or array of magnets
-   *
-   * @example
-   * ```ts
-   * const result = await client.magnet.upload('magnet:?xt=urn:btih:...')
-   * console.log('Magnet ID:', result.magnets[0].id)
-   * ```
-   */
+class MagnetResource extends BaseResource {
   async upload(magnets) {
     const magnetsArray = Array.isArray(magnets) ? magnets : [magnets];
     return this.post("/magnet/upload", {
       magnets: magnetsArray
     });
   }
-  /**
-   * Upload a torrent file
-   *
-   * @param file - The torrent file (Blob or File)
-   * @param filename - Optional filename (defaults to 'torrent.torrent' for Blob, or file.name for File)
-   *
-   * @example
-   * ```ts
-   * const file = new File([buffer], 'torrent.torrent')
-   * const result = await client.magnet.uploadFile(file)
-   *
-   * // Or with a Blob and custom filename
-   * const blob = new Blob([buffer])
-   * const result = await client.magnet.uploadFile(blob, 'my-torrent.torrent')
-   * ```
-   */
   async uploadFile(file, filename) {
-    const formData = new FormData();
+    const formData = new FormData;
     const actualFilename = filename || (file instanceof File ? file.name : "torrent.torrent");
     formData.append("files[]", file, actualFilename);
     return this.postFormData("/magnet/upload/file", formData);
   }
-  /**
-   * Get the status of a specific magnet by ID
-   *
-   * @param id - Magnet ID to get status for
-   *
-   * @example
-   * ```ts
-   * 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 data = await this.post("/magnet/status", { id });
     if (data?.magnets && !Array.isArray(data.magnets)) {
@@ -327,123 +391,10 @@ 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;
+    const body = statusFilter ? { status: statusFilter } : undefined;
     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,
@@ -451,94 +402,27 @@ var MagnetResource = class extends BaseResource {
     };
     return this.post("/magnet/status", body);
   }
-  /**
-   * Delete a magnet
-   *
-   * @param id - The magnet ID to delete
-   *
-   * @example
-   * ```ts
-   * await client.magnet.delete(123)
-   * ```
-   */
   async delete(id) {
     return this.post("/magnet/delete", {
       id
     });
   }
-  /**
-   * Restart one or more failed magnets
-   *
-   * @param ids - Single magnet ID or array of magnet IDs to restart (numbers)
-   *
-   * @example
-   * ```ts
-   * // Restart single magnet
-   * await client.magnet.restart(123)
-   *
-   * // Restart multiple magnets
-   * await client.magnet.restart([123, 456])
-   * ```
-   */
   async restart(ids) {
     const idsArray = Array.isArray(ids) ? ids : [ids];
     return this.post("/magnet/restart", {
       ids: idsArray
     });
   }
-  /**
-   * Get files for a completed magnet
-   *
-   * @param ids - The magnet ID or IDs to get files for
-   *
-   * @example
-   * ```ts
-   * 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 files(ids) {
-    const formData = new FormData();
+    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
-   *
-   * 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, {
-   *   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;
+    const { interval = 3000, maxAttempts = 0, onUpdate, stopOnStatus = "Ready" } = options;
     let attempt = 0;
     while (maxAttempts === 0 || attempt < maxAttempts) {
       attempt++;
@@ -550,105 +434,21 @@ var MagnetResource = class extends BaseResource {
       }
       await new Promise((resolve) => setTimeout(resolve, interval));
     }
-    throw new Error(
-      `Watch timeout: magnet did not reach '${stopOnStatus}' status after ${maxAttempts} attempts`
-    );
+    throw new Error(`Watch timeout: magnet did not reach '${stopOnStatus}' status after ${maxAttempts} attempts`);
   }
-};
+}
 
 // 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
-   */
+class PinResource extends BaseResource {
   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 timeout = options.timeout ?? 600000;
+    const interval = options.interval ?? 3000;
     const startTime = Date.now();
     while (Date.now() - startTime < timeout) {
       const result = await this.check(check, pin);
@@ -659,281 +459,83 @@ var PinResource = class extends BaseResource {
     }
     throw new Error("PIN authorization timeout - user did not authorize within the time limit");
   }
-};
+}
 
 // src/resources/user.ts
-var UserResource = class extends BaseResource {
-  /**
-   * Get user profile information including premium status and quotas
-   *
-   * @example
-   * ```ts
-   * const data = await client.user.getInfo()
-   * console.log(data.user.username, data.user.isPremium)
-   * ```
-   */
+class UserResource extends BaseResource {
   async getInfo() {
     return this.get("/user");
   }
-  /**
-   * Get available hosts for the current user based on their subscription
-   *
-   * @param hostOnly - If true, only return hosts data (exclude streams and redirectors)
-   *
-   * @example
-   * ```ts
-   * const hosts = await client.user.getHosts()
-   * console.log(Object.keys(hosts.hosts))
-   * ```
-   */
   async getHosts(hostOnly) {
-    const params = hostOnly ? { hostOnly: "1" } : void 0;
+    const params = hostOnly ? { hostOnly: "1" } : undefined;
     return this.get("/user/hosts", params);
   }
-  /**
-   * Clear a specific notification by code
-   *
-   * @param code - The notification code to clear
-   *
-   * @example
-   * ```ts
-   * await client.user.clearNotification('SOME_NOTIF_CODE')
-   * ```
-   */
   async clearNotification(code) {
     await this.post("/user/notification/clear", { code });
   }
-  // ============================================
-  // Saved Links Management
-  // ============================================
-  /**
-   * Get all saved links
-   *
-   * @example
-   * ```ts
-   * const savedLinks = await client.user.getLinks()
-   * console.log(savedLinks.links)
-   * ```
-   */
   async getLinks() {
     return this.get("/user/links");
   }
-  /**
-   * Save one or multiple links for later use
-   *
-   * 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(links) {
     const linksArray = Array.isArray(links) ? links : [links];
-    const formData = new FormData();
+    const formData = new FormData;
     for (const link of linksArray) {
       formData.append("links[]", link);
     }
     return this.postFormData("/user/links/save", formData);
   }
-  /**
-   * Delete one or multiple saved links
-   *
-   * 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(links) {
     const linksArray = Array.isArray(links) ? links : [links];
-    const formData = new FormData();
+    const formData = new FormData;
     for (const link of linksArray) {
       formData.append("links[]", link);
     }
     return this.postFormData("/user/links/delete", formData);
   }
-  // ============================================
-  // History Management
-  // ============================================
-  /**
-   * Get user history (if enabled in account settings)
-   *
-   * @example
-   * ```ts
-   * const history = await client.user.getHistory()
-   * console.log(history.links)
-   * ```
-   */
   async getHistory() {
     return this.get("/user/history");
   }
-  /**
-   * Clear user history
-   *
-   * @example
-   * ```ts
-   * await client.user.clearHistory()
-   * ```
-   */
   async clearHistory() {
     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 });
+    return this.post("/user/verif", undefined, { 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 });
+    return this.post("/user/verif/resend", undefined, { 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
-   */
+class VoucherResource extends BaseResource {
   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;
+    const params = quantity ? { quantity } : undefined;
     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.1";
 var DEFAULT_AGENT = "@adbjs/sdk";
-var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_TIMEOUT = 30000;
 var DEFAULT_MAX_RETRIES = 3;
-var AllDebridClient = class {
+
+class AllDebridClient {
   config;
-  /**
-   * User resource for managing user account
-   */
   user;
-  /**
-   * Link resource for unlocking and managing download links
-   */
   link;
-  /**
-   * Magnet resource for managing torrents
-   */
   magnet;
-  /**
-   * 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 = {
@@ -951,17 +553,14 @@ var AllDebridClient = class {
     this.pin = new PinResource(this);
     this.voucher = new VoucherResource(this);
   }
-  /**
-   * Build query string from params
-   */
   buildUrl(path, params) {
     const allParams = {
       agent: this.config.agent,
       ...params
     };
-    const query = new URLSearchParams();
+    const query = new URLSearchParams;
     for (const [key, value] of Object.entries(allParams)) {
-      if (value !== void 0 && value !== null) {
+      if (value !== undefined && value !== null) {
         if (Array.isArray(value)) {
           value.forEach((v) => query.append(`${key}[]`, String(v)));
         } else {
@@ -972,18 +571,10 @@ var AllDebridClient = class {
     const queryString = query.toString();
     return queryString ? `${path}?${queryString}` : path;
   }
-  /**
-   * Make a GET request
-   * @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 {
       const url = this.buildUrl(path, params);
-      const json = await wretch(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).get().json();
+      const json = await dist_default(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).get().json();
       if (json.status === "error" && json.error) {
         throw createTypedError(json.error.code, json.error.message);
       }
@@ -1004,22 +595,13 @@ var AllDebridClient = class {
       throw new NetworkError(error.message || "Network error occurred", error.status);
     }
   }
-  /**
-   * 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 formData = new URLSearchParams();
+      const formData = new URLSearchParams;
       if (body && typeof body === "object") {
         for (const [key, value] of Object.entries(body)) {
-          if (value !== void 0 && value !== null) {
+          if (value !== undefined && value !== null) {
             if (Array.isArray(value)) {
               value.forEach((v) => formData.append(key, String(v)));
             } else {
@@ -1028,7 +610,7 @@ var AllDebridClient = class {
           }
         }
       }
-      const json = await wretch(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).body(formData).post().json();
+      const json = await dist_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);
       }
@@ -1049,19 +631,10 @@ var AllDebridClient = class {
       throw new NetworkError(error.message || "Network error occurred", error.status);
     }
   }
-  /**
-   * Make a POST request with FormData (multipart/form-data)
-   * @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 {
       const url = this.buildUrl(path, params);
-      const json = await wretch(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).body(formData).post().json();
+      const json = await dist_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);
       }
@@ -1082,25 +655,22 @@ var AllDebridClient = class {
       throw new NetworkError(error.message || "Network error occurred", error.status);
     }
   }
-  /**
-   * 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() {
     return this.get("/ping");
   }
+}
+export {
+  createTypedError,
+  VoucherResource,
+  UserResource,
+  PinResource,
+  NetworkError,
+  MagnetResource,
+  MagnetError,
+  LinkResource,
+  LinkError,
+  HostResource,
+  AuthenticationError,
+  AllDebridError,
+  AllDebridClient
 };
-
-export { AllDebridClient, AllDebridError, AuthenticationError, HostResource, LinkError, LinkResource, MagnetError, MagnetResource, NetworkError, PinResource, UserResource, VoucherResource, createTypedError };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map