planvortex 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1594 @@
+'use strict';
+
+var path = require('path');
+
+// src/version.ts
+var PLANVORTEX_API_URL = "https://api.planvortex.com/v1.0.0";
+var VERSION = "0.0.1";
+
+// src/core/errors.ts
+var PLANVORTEX_ERROR_RANGES = [
+  { from: 500, to: 541, family: "auth" },
+  { from: 601, to: 612, family: "user" },
+  { from: 700, to: 715, family: "account" },
+  { from: 800, to: 810, family: "file" },
+  { from: 900, to: 960, family: "publication" },
+  { from: 1e3, to: 1003, family: "general" },
+  { from: 1100, to: 1111, family: "organization" },
+  { from: 1200, to: 1207, family: "role" },
+  { from: 1300, to: 1307, family: "plan_limit" },
+  { from: 1400, to: 1408, family: "plan_limit" },
+  { from: 1500, to: 1512, family: "messaging" },
+  { from: 1600, to: 1601, family: "contact" },
+  { from: 1900, to: 1906, family: "payment" },
+  { from: 2e3, to: 2099, family: "product" },
+  { from: 2100, to: 2199, family: "ai_plan" },
+  { from: 2200, to: 2299, family: "integration" }
+];
+var NO_ERROR_CODE = 0;
+var TOKEN_ERROR_CODES = [501, 522];
+var PlanVortexError = class extends Error {
+  /** El `code` del cuerpo, tal cual. {@link NO_ERROR_CODE} si el error no viene del catálogo. */
+  code;
+  /** La familia del rango: `auth`, `publication`, `plan_limit`... Ver {@link PLANVORTEX_ERROR_RANGES}. */
+  family;
+  /** El `data` del cuerpo. */
+  data;
+  /** Status HTTP, o `undefined` si nunca hubo respuesta. */
+  status;
+  /** `x-request-id`, si el despliegue lo pone. Hoy el servidor no lo emite; un proxy delante sí. */
+  requestId;
+  /** Segundos que pidió esperar la cabecera `Retry-After`, si llegó. */
+  retryAfter;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = new.target.name;
+    this.code = code;
+    this.family = options.family ?? errorFamilyForCode(code) ?? "unknown";
+    this.data = options.data ?? {};
+    this.status = options.status;
+    this.requestId = options.requestId;
+    this.retryAfter = options.retryAfter;
+  }
+};
+var AuthError = class extends PlanVortexError {
+};
+var UserError = class extends PlanVortexError {
+};
+var AccountError = class extends PlanVortexError {
+};
+var FileError = class extends PlanVortexError {
+};
+var PublicationError = class extends PlanVortexError {
+};
+var OrganizationError = class extends PlanVortexError {
+};
+var PlanLimitError = class extends PlanVortexError {
+};
+var MessagingError = class extends PlanVortexError {
+};
+var ContactError = class extends PlanVortexError {
+};
+var ProductError = class extends PlanVortexError {
+};
+var AiPlanError = class extends PlanVortexError {
+};
+var IntegrationError = class extends PlanVortexError {
+};
+var PlanVortexConnectionError = class extends PlanVortexError {
+  /** `true` si lo que se agotó fue nuestro propio timeout, no la red. */
+  timeout;
+  constructor(message, options = {}) {
+    super(NO_ERROR_CODE, message, { ...options, family: "connection" });
+    this.timeout = options.timeout ?? false;
+  }
+};
+var PlanVortexAuthenticationError = class extends PlanVortexError {
+  /** `invalid_client`, `invalid_request`, `unsupported_grant_type`, `slow_down` o `server_error`. */
+  oauthError;
+  constructor(oauthError, description, options = {}) {
+    super(NO_ERROR_CODE, description, { ...options, family: "oauth" });
+    this.oauthError = oauthError;
+  }
+};
+var PlanVortexConfigError = class extends PlanVortexError {
+  constructor(message) {
+    super(NO_ERROR_CODE, message, { family: "config" });
+  }
+};
+function errorFamilyForCode(code) {
+  return PLANVORTEX_ERROR_RANGES.find((range) => code >= range.from && code <= range.to)?.family;
+}
+var FAMILY_CLASSES = {
+  auth: AuthError,
+  user: UserError,
+  account: AccountError,
+  file: FileError,
+  publication: PublicationError,
+  organization: OrganizationError,
+  plan_limit: PlanLimitError,
+  messaging: MessagingError,
+  contact: ContactError,
+  product: ProductError,
+  ai_plan: AiPlanError,
+  integration: IntegrationError
+};
+function isApiErrorBody(body) {
+  return typeof body === "object" && body !== null && typeof body.code === "number";
+}
+function createErrorFromResponse(input) {
+  const options = {
+    status: input.status,
+    ...input.requestId === void 0 ? {} : { requestId: input.requestId },
+    ...input.retryAfter === void 0 ? {} : { retryAfter: input.retryAfter }
+  };
+  if (isApiErrorBody(input.body)) {
+    const family = errorFamilyForCode(input.body.code);
+    const ErrorClass = (family === void 0 ? void 0 : FAMILY_CLASSES[family]) ?? PlanVortexError;
+    return new ErrorClass(input.body.code, input.body.message ?? "PlanVortex error", {
+      ...options,
+      data: input.body.data ?? {}
+    });
+  }
+  return new PlanVortexError(NO_ERROR_CODE, `HTTP ${input.status}`, {
+    ...options,
+    family: "http",
+    data: typeof input.body === "object" && input.body !== null ? input.body : { body: input.body }
+  });
+}
+function isPlanVortexError(error) {
+  return error instanceof PlanVortexError;
+}
+function isTokenError(error) {
+  return isPlanVortexError(error) && TOKEN_ERROR_CODES.includes(error.code);
+}
+
+// src/core/auth.ts
+var TOKEN_REFRESH_MARGIN_MS = 6e4;
+var TOKEN_PATH = "/oauth/token";
+var StaticTokenAuth = class {
+  constructor(token) {
+    this.token = token;
+  }
+  token;
+  getToken() {
+    return Promise.resolve(this.token);
+  }
+  invalidate() {
+  }
+};
+var ClientCredentialsAuth = class {
+  constructor(http, options) {
+    this.http = http;
+    this.options = options;
+    this.now = options.now ?? Date.now;
+  }
+  http;
+  options;
+  now;
+  cached;
+  /** La petición de token en vuelo. Es el cerrojo: mientras exista, todos esperan a ésta. */
+  pending;
+  async getToken() {
+    const cached = this.cached;
+    if (cached && cached.expiresAt - this.now() > TOKEN_REFRESH_MARGIN_MS) {
+      return cached.token;
+    }
+    this.pending ??= this.fetchToken().finally(() => {
+      this.pending = void 0;
+    });
+    return this.pending;
+  }
+  invalidate() {
+    this.cached = void 0;
+  }
+  async fetchToken() {
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this.options.clientId,
+      client_secret: this.options.clientSecret
+    });
+    if (this.options.scope) {
+      body.set("scope", this.options.scope);
+    }
+    let token;
+    try {
+      const response = await this.http.request({
+        method: "POST",
+        path: TOKEN_PATH,
+        body,
+        //Es el único POST reintentable de la librería: pedir un token no crea nada.
+        idempotent: true
+      });
+      token = response.data;
+    } catch (error) {
+      throw toAuthenticationError(error);
+    }
+    if (!token?.access_token) {
+      throw new PlanVortexAuthenticationError(
+        "server_error",
+        "El endpoint de token respondi\xF3 sin access_token"
+      );
+    }
+    const lifetimeMs = (Number(token.expires_in) > 0 ? Number(token.expires_in) : 3600) * 1e3;
+    this.cached = { token: token.access_token, expiresAt: this.now() + lifetimeMs };
+    return token.access_token;
+  }
+};
+function toAuthenticationError(error) {
+  if (!isPlanVortexError(error) || error.status === void 0) {
+    return error;
+  }
+  const body = error.data;
+  const oauthError = typeof body.error === "string" ? body.error : "invalid_client";
+  const description = typeof body.error_description === "string" ? body.error_description : error.message;
+  return new PlanVortexAuthenticationError(oauthError, description, {
+    status: error.status,
+    ...error.requestId === void 0 ? {} : { requestId: error.requestId },
+    ...error.retryAfter === void 0 ? {} : { retryAfter: error.retryAfter },
+    cause: error
+  });
+}
+
+// src/core/http.ts
+var DEFAULT_RETRY = {
+  maxRetries: 2,
+  baseDelayMs: 500,
+  maxDelayMs: 8e3
+};
+var DEFAULT_TIMEOUT_MS = 12e4;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
+var PRE_FLIGHT_NETWORK_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EHOSTUNREACH",
+  "ENETUNREACH"
+]);
+function isIdempotent(request) {
+  return request.idempotent ?? request.method !== "POST";
+}
+function networkErrorCode(error) {
+  const cause = error?.cause;
+  const code = cause?.code ?? error?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function parseRetryAfter(header, now = Date.now()) {
+  if (!header) {
+    return void 0;
+  }
+  const seconds = Number(header);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return seconds;
+  }
+  const date = Date.parse(header);
+  if (Number.isNaN(date)) {
+    return void 0;
+  }
+  return Math.max(0, Math.round((date - now) / 1e3));
+}
+function buildQuery(query) {
+  if (!query) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        params.append(key, String(item));
+      }
+      continue;
+    }
+    params.append(key, value instanceof Date ? value.toISOString() : String(value));
+  }
+  const serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var HttpClient = class {
+  baseUrl;
+  timeoutMs;
+  retry;
+  hooks;
+  fetchImpl;
+  baseHeaders;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.retry = { ...DEFAULT_RETRY, ...config.retry };
+    this.hooks = config.hooks ?? {};
+    this.fetchImpl = config.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    this.baseHeaders = Object.fromEntries(
+      Object.entries(config.headers ?? {}).map(([key, value]) => [key.toLowerCase(), value])
+    );
+  }
+  async request(request) {
+    const url = `${this.baseUrl}${request.path}${buildQuery(request.query)}`;
+    const { body, headers } = this.prepareBody(request);
+    const timeoutMs = request.timeoutMs ?? this.timeoutMs;
+    const retryable = isIdempotent(request);
+    let attempt = 0;
+    for (; ; ) {
+      attempt++;
+      this.hooks.onRequest?.({ method: request.method, url, attempt });
+      const startedAt = Date.now();
+      let response;
+      try {
+        response = await this.send(url, request, body, headers, timeoutMs);
+      } catch (error) {
+        const failure = this.toConnectionError(error, request, timeoutMs);
+        const canRetry = retryable || PRE_FLIGHT_NETWORK_CODES.has(networkErrorCode(error) ?? "");
+        if (!canRetry || attempt > this.retry.maxRetries) {
+          throw failure;
+        }
+        const delayMs = this.backoff(attempt);
+        this.hooks.onRetry?.({
+          method: request.method,
+          url,
+          attempt,
+          delayMs,
+          status: void 0,
+          error
+        });
+        await sleep(delayMs);
+        continue;
+      }
+      this.hooks.onResponse?.({
+        method: request.method,
+        url,
+        attempt,
+        status: response.status,
+        durationMs: Date.now() - startedAt
+      });
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      if (response.ok) {
+        return {
+          data: await this.parseBody(response, request),
+          status: response.status,
+          headers: response.headers,
+          requestId
+        };
+      }
+      const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+      const shouldRetry = retryable && RETRYABLE_STATUS.has(response.status) && attempt <= this.retry.maxRetries;
+      const waitMs = retryAfter === void 0 ? this.backoff(attempt) : retryAfter * 1e3;
+      if (!shouldRetry || waitMs > this.retry.maxDelayMs) {
+        throw await this.toApiError(response, requestId, retryAfter);
+      }
+      await response.arrayBuffer().catch(() => void 0);
+      this.hooks.onRetry?.({
+        method: request.method,
+        url,
+        attempt,
+        delayMs: waitMs,
+        status: response.status,
+        error: void 0
+      });
+      await sleep(waitMs);
+    }
+  }
+  /** Backoff exponencial con jitter completo: aleatorio entre 0 y el tope de ese intento. */
+  backoff(attempt) {
+    const ceiling = Math.min(this.retry.maxDelayMs, this.retry.baseDelayMs * 2 ** (attempt - 1));
+    return Math.round(Math.random() * ceiling);
+  }
+  prepareBody(request) {
+    const headers = { accept: "application/json", ...this.baseHeaders };
+    for (const [key, value] of Object.entries(request.headers ?? {})) {
+      headers[key.toLowerCase()] = value;
+    }
+    if (request.body === void 0) {
+      return { body: void 0, headers };
+    }
+    if (request.body instanceof FormData || request.body instanceof URLSearchParams) {
+      return { body: request.body, headers };
+    }
+    if (typeof request.body === "string" || request.body instanceof Uint8Array) {
+      return { body: request.body, headers };
+    }
+    headers["content-type"] = "application/json";
+    return { body: JSON.stringify(request.body), headers };
+  }
+  async send(url, request, body, headers, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new PlanVortexTimeout()), timeoutMs);
+    const external = request.signal;
+    const forward = () => controller.abort(external?.reason);
+    if (external) {
+      if (external.aborted) {
+        clearTimeout(timer);
+        throw external.reason;
+      }
+      external.addEventListener("abort", forward, { once: true });
+    }
+    try {
+      return await this.fetchImpl(url, {
+        method: request.method,
+        ...body === void 0 ? {} : { body },
+        headers,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (controller.signal.reason instanceof PlanVortexTimeout && !external?.aborted) {
+        throw controller.signal.reason;
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      external?.removeEventListener("abort", forward);
+    }
+  }
+  /**
+   * Un abort tiene dos orígenes y sólo uno es nuestro: si canceló el integrador, su error sale tal
+   * cual —envolverlo le rompería el `if (e.name === "AbortError")` que tenga escrito.
+   */
+  toConnectionError(error, request, timeoutMs) {
+    if (error instanceof PlanVortexTimeout || error?.name === "TimeoutError") {
+      return new PlanVortexConnectionError(
+        `${request.method} ${request.path} agot\xF3 el timeout de ${timeoutMs} ms`,
+        { timeout: true, cause: error }
+      );
+    }
+    if (request.signal?.aborted) {
+      return error;
+    }
+    const code = networkErrorCode(error);
+    return new PlanVortexConnectionError(
+      `${request.method} ${request.path} no pudo conectar${code ? ` (${code})` : ""}`,
+      { timeout: false, cause: error }
+    );
+  }
+  async toApiError(response, requestId, retryAfter) {
+    const body = await this.readBody(response);
+    return createErrorFromResponse({ body, status: response.status, requestId, retryAfter });
+  }
+  async parseBody(response, request) {
+    if (request.parse === "none" || response.status === 204) {
+      return void 0;
+    }
+    return this.readBody(response);
+  }
+  /** JSON si se puede; si no, el texto crudo. Un cuerpo vacío es `undefined`, nunca un throw. */
+  async readBody(response) {
+    const text = await response.text().catch(() => "");
+    if (!text) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+};
+var PlanVortexTimeout = class extends Error {
+  constructor() {
+    super("PlanVortex request timeout");
+    this.name = "TimeoutError";
+  }
+};
+
+// src/core/pagination.ts
+var DEFAULT_PAGE_SIZE = 50;
+var MAX_PAGES = 1e4;
+function unwrapList(body, key) {
+  const envelope = body;
+  const data = envelope?.[key];
+  if (!Array.isArray(data)) {
+    throw new PlanVortexError(
+      NO_ERROR_CODE,
+      `La respuesta no trae "${key}": el sobre de la lista no es el esperado.`,
+      {
+        family: "http",
+        data: { expected: key, received: envelope ? Object.keys(envelope) : envelope }
+      }
+    );
+  }
+  const total = envelope?.total;
+  return {
+    data,
+    //`total` viaja siempre, pero si un despliegue viejo no lo mandara, la longitud de la
+    //página es mejor respuesta que un `undefined` colándose como número.
+    total: typeof total === "number" ? total : data.length
+  };
+}
+function unwrapOne(body, key) {
+  const envelope = body;
+  const value = envelope?.[key];
+  if (value === void 0 || value === null) {
+    throw new PlanVortexError(NO_ERROR_CODE, `La respuesta no trae "${key}".`, {
+      family: "http",
+      data: { expected: key, received: envelope ? Object.keys(envelope) : envelope }
+    });
+  }
+  return value;
+}
+async function* iteratePages(fetchPage, options = {}) {
+  const limit = options.limit ?? DEFAULT_PAGE_SIZE;
+  let offset = options.offset ?? 0;
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const { data } = await fetchPage({ limit, offset });
+    if (!data.length) {
+      return;
+    }
+    for (const item of data) {
+      yield item;
+    }
+    if (data.length < limit) {
+      return;
+    }
+    offset += data.length;
+  }
+  throw new PlanVortexError(
+    NO_ERROR_CODE,
+    `La paginaci\xF3n pas\xF3 de ${MAX_PAGES} p\xE1ginas: el servidor no est\xE1 avanzando con el offset.`,
+    { family: "http" }
+  );
+}
+
+// src/resources/base.ts
+var Resource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async send(request, options = {}) {
+    const response = await this.client.request({
+      ...request,
+      ...options.signal === void 0 ? {} : { signal: options.signal },
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+    });
+    return response.data;
+  }
+  /*
+   * Los cuatro verbos se llaman `httpGet`/`httpPost`/... y no `get`/`post`/... porque los
+   * recursos que heredan de aquí SÍ tienen métodos públicos con esos nombres —`uploads.get(org,
+   * id)` es lo que un integrador escribe— y en TypeScript una subclase no puede declarar un
+   * miembro con la firma de uno heredado. Sin el prefijo, `this.get(...)` dentro de un recurso
+   * resolvía a su propio método público y compilaba llamando a otra cosa.
+   */
+  httpGet(path, query, options) {
+    return this.send({ method: "GET", path, ...query ? { query } : {} }, options);
+  }
+  httpPost(path, body, options, query) {
+    return this.send(
+      { method: "POST", path, ...body === void 0 ? {} : { body }, ...query ? { query } : {} },
+      options
+    );
+  }
+  httpPut(path, body, options) {
+    return this.send({ method: "PUT", path, ...body === void 0 ? {} : { body } }, options);
+  }
+  httpDelete(path, query, options) {
+    return this.send({ method: "DELETE", path, ...query ? { query } : {} }, options);
+  }
+  /** `GET` de una lista, ya desenvuelta a `{data, total}`. */
+  async getList(path, key, query, options) {
+    return unwrapList(await this.httpGet(path, query, options), key);
+  }
+  /** `GET` de un recurso suelto, ya sacado de su sobre. */
+  async getOne(path, key, query, options) {
+    return unwrapOne(await this.httpGet(path, query, options), key);
+  }
+  /** `POST` que devuelve un recurso envuelto. */
+  async postOne(path, key, body, options, query) {
+    return unwrapOne(await this.httpPost(path, body, options, query), key);
+  }
+  /** `PUT` que devuelve un recurso envuelto. */
+  async putOne(path, key, body, options) {
+    return unwrapOne(await this.httpPut(path, body, options), key);
+  }
+};
+function requireId(value, name) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError(`Falta ${name}.`);
+  }
+  return value;
+}
+
+// src/resources/accounts.ts
+var AccountsResource = class extends Resource {
+  /**
+   * Los enlaces de autorización de cada red conectable, para mandar a la persona a la suya.
+   *
+   * **Con credenciales de app contesta 519.** Se llama con un cliente autenticado con el token
+   * temporal: `pv.asTemporalToken(token).accounts.connectLinks(orgId)`.
+   *
+   * **Una red que no puede dar enlace simplemente no aparece**, y eso es una respuesta legítima y
+   * no un fallo: es lo que pasa con Discord en una organización que todavía no ha guardado sus
+   * propias credenciales de bot.
+   *
+   * OJO: la red devuelve al usuario a un front de PlanVortex, no a una URL tuya — ver
+   * `redirect_uri` en {@link ConnectLinksOptions}.
+   */
+  async connectLinks(idOrganization, options = {}) {
+    return unwrapOne(
+      await this.httpGet(
+        `/organizations/${requireId(idOrganization, "idOrganization")}/connect_links`,
+        { social_network: options.social_network, redirect_uri: options.redirect_uri },
+        options
+      ),
+      "links"
+    );
+  }
+  /**
+   * Completa la conexión con lo que la red social pegó a la URL de vuelta.
+   *
+   * **Esta llamada no la necesita la mayoría.** La URL de vuelta la construye la red a partir del
+   * enlace de {@link connectLinks}, y apunta a un front de PlanVortex: es ese front el que llama
+   * aquí. El método existe para quien sirve su propia interfaz en uno de los dominios registrados
+   * en el servidor. En la integración normal —la del ejemplo `connect-flow`— basta con mandar al
+   * usuario a la `url` del token temporal y esperarlo de vuelta.
+   *
+   * **El endpoint contesta 200 aunque haya fallado**, con el error dentro del cuerpo, porque el
+   * navegador aterriza aquí desde una redirección y un 400 crudo sería una página rota. La
+   * librería deshace ese apaño: si viene `errorCode`, **lanza** el error que le toca, igual que
+   * cualquier otro método. Lo que devuelve son sólo cuentas buenas.
+   *
+   * **Y vuelven SIN habilitar**: no ocupan plaza del plan ni publican hasta que se llama a
+   * {@link enable}. Una sola autorización puede dejar varias — un usuario de Facebook con cuatro
+   * páginas son cuatro—, y por eso hay un paso de elección en medio.
+   */
+  async connect(idOrganization, socialNetwork, params = {}, options = {}) {
+    const path = `/organizations/${requireId(idOrganization, "idOrganization")}/account-connect/${requireId(socialNetwork, "socialNetwork")}`;
+    const body = await this.httpGet(path, params, options);
+    if (body.errorCode) {
+      const code = Number(body.errorCode);
+      throw createErrorFromResponse({
+        body: {
+          code: Number.isFinite(code) ? code : NO_ERROR_CODE,
+          message: body.errorMsg || `La conexi\xF3n no se complet\xF3 (${body.errorCode}).`
+        },
+        status: 200
+      });
+    }
+    return {
+      accounts: body.accounts ?? [],
+      ...body.redirect_uri === void 0 ? {} : { redirect_uri: body.redirect_uri }
+    };
+  }
+  /**
+   * Da de alta una de las cuentas que dejó {@link connect}, o recupera una que se desconectó
+   * mientras su token guardado siga sirviendo (si no, error 700 y hay que autorizar otra vez).
+   *
+   * **Es el paso que ocupa plaza del plan**: con el cupo lleno contesta 706, así que se llama una
+   * a una y se mira el hueco antes (`organizations.limits`). Y es también el que enciende los
+   * webhooks de la red, en cualquier plan que no sea el gratuito.
+   */
+  async enable(idOrganization, idAccount, options = {}) {
+    const body = await this.httpPost(
+      `${this.path(idOrganization, idAccount)}/enable`,
+      void 0,
+      options
+    );
+    return body.redirect_uri === void 0 ? {} : { redirect_uri: body.redirect_uri };
+  }
+  /** Las cuentas de una organización. */
+  async list(idOrganization, options = {}) {
+    return this.getList(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/accounts`,
+      "accounts",
+      {
+        offset: options.offset,
+        limit: options.limit,
+        name: options.name,
+        social_network: options.social_network,
+        accounts: options.accounts,
+        capability: options.capability
+      },
+      options
+    );
+  }
+  /** Las cuentas de una organización, encadenando páginas. */
+  iterate(idOrganization, options = {}) {
+    return iteratePages((page) => this.list(idOrganization, { ...options, ...page }), options);
+  }
+  /** La ficha de una cuenta. */
+  async get(idOrganization, idAccount, options = {}) {
+    return this.getOne(this.path(idOrganization, idAccount), "account", void 0, options);
+  }
+  /** Cambia el nombre con el que la cuenta se ve en PlanVortex. Es lo único editable. */
+  async update(idOrganization, idAccount, body, options = {}) {
+    return this.putOne(this.path(idOrganization, idAccount), "account", body, options);
+  }
+  /**
+   * Desconecta la cuenta y **borra sus publicaciones**. Lo ya publicado en la red se queda donde
+   * está: esto no la toca.
+   */
+  async remove(idOrganization, idAccount, options = {}) {
+    await this.httpDelete(this.path(idOrganization, idAccount), void 0, options);
+  }
+  /**
+   * La serie de métricas ya medidas de una cuenta.
+   *
+   * Es lectura de lo guardado, no una llamada a la red: mirar la gráfica no cuesta créditos. El
+   * agrupado lo decide el rango — hasta 31 días por día, hasta 720 por mes, y de ahí por año— y
+   * viene dicho en `group`.
+   */
+  async metrics(idOrganization, idAccount, options = {}) {
+    return this.httpGet(
+      `${this.path(idOrganization, idAccount)}/metrics`,
+      {
+        from_date: options.from_date,
+        to_date: options.to_date,
+        names: options.names
+      },
+      options
+    );
+  }
+  /**
+   * Los nombres CRUDOS de las métricas que publica la red de esta cuenta.
+   *
+   * Son los que se pasan a {@link metrics} y los que vuelven en cada fila. No es el vocabulario
+   * común —eso es `metrics` de una publicación—: aquí cada red habla su idioma
+   * (`page_impressions`, `total_interactions`, `allPageViews`).
+   */
+  async metricList(idOrganization, idAccount, options = {}) {
+    return this.httpGet(
+      `${this.path(idOrganization, idAccount)}/metric_list`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * El menú fijo del chat, una entrada por idioma.
+   *
+   * Sólo las redes con mensajería lo tienen: en las demás la llamada devuelve el error 710. Se
+   * comprueba con `persistent_menu` de `catalog.socialCapabilities()`.
+   */
+  async getPersistentMenu(idOrganization, idAccount, options = {}) {
+    return unwrapOne(
+      await this.httpGet(
+        `${this.path(idOrganization, idAccount)}/persistent_menu`,
+        void 0,
+        options
+      ),
+      "persistent_menu"
+    );
+  }
+  /**
+   * Reemplaza el menú fijo del chat. Es un REEMPLAZO: lo que no vaya en el array desaparece.
+   *
+   * La entrada con `locale: "default"` es obligatoria — es la que se enseña cuando ninguna otra
+   * encaja.
+   */
+  async setPersistentMenu(idOrganization, idAccount, menu, options = {}) {
+    return unwrapOne(
+      await this.httpPost(
+        `${this.path(idOrganization, idAccount)}/persistent_menu`,
+        { persistent_menu: menu },
+        options
+      ),
+      "persistent_menu"
+    );
+  }
+  path(idOrganization, idAccount) {
+    return `/organizations/${requireId(idOrganization, "idOrganization")}/accounts/${requireId(idAccount, "idAccount")}`;
+  }
+};
+
+// src/resources/catalog.ts
+var CatalogResource = class extends Resource {
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Las redes soportadas.
+   *
+   * **La lista crece varias veces al año.** No la copies a una constante tuya: pídela.
+   */
+  async socialNetworks(options) {
+    return this.cached(
+      "/social_networks",
+      () => this.httpGet("/social_networks", void 0, options)
+    );
+  }
+  /** Las redes que aceptan publicaciones. Ni WhatsApp ni Google Business están. */
+  async allowedSocialPublications(options) {
+    return this.cached(
+      "/allowed_social_publications",
+      () => this.httpGet("/allowed_social_publications", void 0, options)
+    );
+  }
+  /**
+   * Las redes con conversaciones.
+   *
+   * Va en `POST` y no en `GET`, que es raro y es así: es la ruta que hay. No manda cuerpo.
+   */
+  async allowedSocialMessages(options) {
+    return this.cached(
+      "/allowed_social_messages",
+      () => this.httpPost("/allowed_social_messages", void 0, options)
+    );
+  }
+  /**
+   * La matriz red → qué sabe hacer: publicar, mensajes, productos, webhooks, menú persistente y
+   * comentarios.
+   *
+   * Es lo que evita ofrecer una cuenta en una pantalla que su red no soporta — WhatsApp en el
+   * compositor, LinkedIn en el chat.
+   */
+  async socialCapabilities(options) {
+    return this.cached(
+      "/social_capabilities",
+      () => this.httpGet("/social_capabilities", void 0, options)
+    );
+  }
+  /**
+   * La matriz red → qué se puede hacer con un comentario: responder, ocultar, borrar el propio y
+   * borrar el de otro.
+   *
+   * Va **aparte** de {@link socialCapabilities} porque aquélla es `{[capacidad]: boolean}` y esto
+   * es un objeto por red: meterlo dentro rompería su forma. Que la red tenga comentarios no dice
+   * lo suficiente — Instagram, X y Bluesky no dejan borrar el de otro, LinkedIn no tiene
+   * "ocultar", y Google Business sólo deja borrar **nuestra propia respuesta**.
+   */
+  async socialCommentActions(options) {
+    return this.cached(
+      "/social_comment_actions",
+      () => this.httpGet("/social_comment_actions", void 0, options)
+    );
+  }
+  /**
+   * Los topes de cada red, por los que el servidor valida.
+   *
+   * Bluesky lleva **dos** cuentas del mismo texto y en unidades distintas: 300 grafemas en
+   * `characters` y 3.000 bytes en `max_post_bytes`. `.length` miente en las dos direcciones —un
+   * emoji de familia es UN grafema y 25 bytes—, así que un contador que use `.length` da por
+   * bueno lo que la API rechaza y al revés.
+   */
+  async socialLimits(options) {
+    return this.cached(
+      "/social_limits",
+      () => this.httpGet("/social_limits", void 0, options)
+    );
+  }
+  /** Los topes de una publicación que no dependen de la red: hoy, cuántos reintentos manuales admite. */
+  async publicationLimits(options) {
+    return this.cached(
+      "/publication_limits",
+      () => this.httpGet("/publication_limits", void 0, options)
+    );
+  }
+  /**
+   * Los recortes que acepta cada red.
+   *
+   * Se indexa por red **y por formato** (`facebook`, `facebook_reels`, `facebook_stories`), así
+   * que no todas las claves son una red. `values` y `text` son arrays paralelos: mismo índice,
+   * mismo recorte.
+   */
+  async allowedAspectRatios(options) {
+    return this.cached(
+      "/allowed_aspect_ratios",
+      () => this.httpGet("/allowed_aspect_ratios", void 0, options)
+    );
+  }
+  /** Tira la caché. Para un proceso largo que quiera enterarse de una red nueva sin reiniciar. */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Guarda la PROMESA, no el resultado: dos llamadas a la vez comparten una petición en vez de
+   * lanzar dos. Si falla, la entrada se retira para que el siguiente intento vuelva a pedirla —
+   * cachear un fallo de red deja la instancia rota para siempre.
+   */
+  cached(key, fetch) {
+    const hit = this.cache.get(key);
+    if (hit) {
+      return hit;
+    }
+    const pending = fetch().catch((error) => {
+      this.cache.delete(key);
+      throw error;
+    });
+    this.cache.set(key, pending);
+    return pending;
+  }
+};
+
+// src/resources/clients.ts
+var ClientsResource = class extends Resource {
+  /** Los clientes que puede ver quien llama. Con credenciales de app, el suyo. */
+  async list(options = {}) {
+    return this.getList("/clients", "clients", listQuery(options), options);
+  }
+  /** Los clientes, página a página, sin tener que llevar el `offset` a mano. */
+  iterate(options = {}) {
+    return iteratePages((page) => this.list({ ...options, ...page }), options);
+  }
+  /** La ficha de un cliente. */
+  async get(idClient, options = {}) {
+    return this.getOne(
+      `/clients/${requireId(idClient, "idClient")}`,
+      "client",
+      options.getUse ? { getUse: true } : void 0,
+      options
+    );
+  }
+  /** Cambia lo poco que de un cliente se puede cambiar: hoy, su nombre. */
+  async update(idClient, body, options = {}) {
+    return this.putOne(`/clients/${requireId(idClient, "idClient")}`, "client", body, options);
+  }
+  /** Las organizaciones RAÍZ de un cliente. Las hijas cuelgan de cada una. */
+  async organizations(idClient, options = {}) {
+    return this.getList(
+      `/clients/${requireId(idClient, "idClient")}/organizations`,
+      "organizations",
+      { ...listQuery(options), name: options.name },
+      options
+    );
+  }
+  /** Las organizaciones raíz de un cliente, encadenando páginas. */
+  iterateOrganizations(idClient, options = {}) {
+    return iteratePages(
+      (page) => this.organizations(idClient, { ...options, ...page }),
+      options
+    );
+  }
+  /** Crea una organización raíz. Lo que se le asigne se descuenta de lo que el cliente tiene. */
+  async createOrganization(idClient, body, options = {}) {
+    return this.postOne(
+      `/clients/${requireId(idClient, "idClient")}/organizations`,
+      "organization",
+      body,
+      options
+    );
+  }
+  /** Cambia una organización raíz: su nombre o el cupo que tiene asignado. */
+  async updateOrganization(idClient, idOrganization, body, options = {}) {
+    return this.putOne(
+      `/clients/${requireId(idClient, "idClient")}/organizations/${requireId(idOrganization, "idOrganization")}`,
+      "organization",
+      body,
+      options
+    );
+  }
+  /**
+   * Borra una organización raíz **con todo lo que tiene dentro**: sus organizaciones hijas, sus
+   * cuentas, sus publicaciones, sus ficheros y sus comentarios. No se deshace.
+   */
+  async deleteOrganization(idClient, idOrganization, options = {}) {
+    await this.httpDelete(
+      `/clients/${requireId(idClient, "idClient")}/organizations/${requireId(idOrganization, "idOrganization")}`,
+      void 0,
+      options
+    );
+  }
+};
+function listQuery(options) {
+  return {
+    offset: options.offset,
+    limit: options.limit,
+    //`getUse` sólo se manda cuando se pide: un `getUse=false` en la query es ruido en el log.
+    getUse: options.getUse ? true : void 0
+  };
+}
+
+// src/resources/organizations.ts
+var OrganizationsResource = class extends Resource {
+  /** La ficha de una organización. */
+  async get(idOrganization, options = {}) {
+    return this.getOne(
+      `/organizations/${requireId(idOrganization, "idOrganization")}`,
+      "organization",
+      options.getUse ? { getUse: true } : void 0,
+      options
+    );
+  }
+  /** Cambia el nombre de una organización o el cupo que tiene asignado. */
+  async update(idOrganization, body, options = {}) {
+    return this.putOne(
+      `/organizations/${requireId(idOrganization, "idOrganization")}`,
+      "organization",
+      body,
+      options
+    );
+  }
+  /**
+   * Borra una organización **con todo lo que tiene dentro**: sus hijas, sus cuentas, sus
+   * publicaciones, sus ficheros y sus comentarios. No se deshace.
+   */
+  async remove(idOrganization, options = {}) {
+    await this.httpDelete(
+      `/organizations/${requireId(idOrganization, "idOrganization")}`,
+      void 0,
+      options
+    );
+  }
+  /** Las organizaciones que cuelgan de ésta. */
+  async children(idOrganization, options = {}) {
+    return this.getList(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/organizations`,
+      "organizations",
+      {
+        offset: options.offset,
+        limit: options.limit,
+        name: options.name,
+        getUse: options.getUse ? true : void 0
+      },
+      options
+    );
+  }
+  /** Las organizaciones hijas, encadenando páginas. */
+  iterateChildren(idOrganization, options = {}) {
+    return iteratePages(
+      (page) => this.children(idOrganization, { ...options, ...page }),
+      options
+    );
+  }
+  /** Crea una organización hija con el cupo que se le reparta del plan de ésta. */
+  async createChild(idOrganization, body, options = {}) {
+    return this.postOne(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/organizations`,
+      "organization",
+      body,
+      options
+    );
+  }
+  /**
+   * Lo que esta organización puede usar de verdad, con la cascada ya resuelta: su plan propio, o
+   * el del primer padre que tenga uno, o el resto sin repartir del cliente.
+   *
+   * Es lo que hay que mirar antes de conectar una cuenta o programar una publicación, no
+   * `organization.actual_plan`.
+   */
+  async limits(idOrganization, options = {}) {
+    return this.httpGet(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/limits`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * El consumo de esta organización y lo que ya tiene repartido a sus hijas.
+   *
+   * Es un atajo de `get(id, {getUse: true})` que devuelve sólo las dos cifras, que es lo que se
+   * quiere cuando se está pintando una barra de "3 de 5 cuentas".
+   */
+  async use(idOrganization, options = {}) {
+    const organization = await this.get(idOrganization, { ...options, getUse: true });
+    return { actual_use: organization.actual_use, actual_asigned: organization.actual_asigned };
+  }
+  /**
+   * Emite el token temporal con el que **una persona** conecta una cuenta social a esta
+   * organización. Es la única forma que tiene una app de que se le conecte una cuenta.
+   *
+   * Y es el reverso exacto del resto del flujo: éste es el endpoint que **exige credenciales de
+   * app** —con un token de usuario contesta 514—, mientras que los tres que vienen después
+   * (`accounts.connectLinks`, `accounts.connect`, `accounts.enable`) las rechazan con un 519.
+   *
+   * Vuelven las dos formas del mismo credencial, y las dos sirven:
+   *
+   *  - **`url`** — el camino alojado. Se redirige al usuario ahí y PlanVortex se encarga de la
+   *    elección de red, del OAuth y de la pantalla donde elige qué cuentas dar de alta. Es lo que
+   *    hace el ejemplo `examples/connect-flow`, y lo que casi todo el mundo quiere.
+   *  - **`token`** — el credencial suelto, para `pv.asTemporalToken(token)` cuando la interfaz la
+   *    pone el integrador.
+   *
+   * Caduca en una hora y **sólo vale para esta organización**: usarlo contra otra contesta 1101.
+   */
+  async createConnectToken(idOrganization, options = {}) {
+    return this.httpGet(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/temporal_connect_token`,
+      { social_network: options.social_network, redirect_uri: options.redirect_uri },
+      options
+    );
+  }
+};
+
+// src/resources/publications.ts
+var PublicationsResource = class extends Resource {
+  /**
+   * Crea una publicación en una cuenta.
+   *
+   * Sin `publish_date` se envía en esta misma petición y la respuesta ya dice si salió
+   * (`state: "sended"`) o si falló y por qué. Con fecha futura queda `ready`.
+   *
+   * ```ts
+   * const publication = await pv.publications.create(orgId, accountId, {
+   *     social_network: "instagram",
+   *     text: "Nuevo horno, nuevas hogazas",
+   *     files: [upload._id],
+   *     publish_date: new Date("2026-09-01T10:00:00Z"),
+   * });
+   * ```
+   */
+  async create(idOrganization, idAccount, body, options = {}) {
+    return this.postOne(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/accounts/${requireId(idAccount, "idAccount")}/publish`,
+      "publication",
+      serializeInput(body),
+      options
+    );
+  }
+  /** Una publicación, con sus ficheros y su cuenta ya resueltos. */
+  async get(idOrganization, idPublication, options = {}) {
+    return this.getOne(
+      this.path(idOrganization, idPublication),
+      "publication",
+      void 0,
+      options
+    );
+  }
+  /** Las publicaciones de una organización. */
+  async list(idOrganization, options = {}) {
+    return this.getList(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/publish`,
+      "publications",
+      listQuery2(options),
+      options
+    );
+  }
+  /** Las publicaciones de una organización, encadenando páginas. */
+  iterate(idOrganization, options = {}) {
+    return iteratePages(
+      (page) => this.list(idOrganization, { ...options, ...page }),
+      options
+    );
+  }
+  /** Las publicaciones de UNA cuenta. Mismos filtros que {@link list}. */
+  async listByAccount(idOrganization, idAccount, options = {}) {
+    return this.getList(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/accounts/${requireId(idAccount, "idAccount")}/publish`,
+      "publications",
+      listQuery2(options),
+      options
+    );
+  }
+  /**
+   * Cambia una publicación que todavía no ha salido. Una `sended` devuelve el error 921.
+   *
+   * Editar PONE EL CONTADOR DE REINTENTOS A CERO: el contador cuenta intentos de publicar *ese*
+   * contenido, y acabas de cambiarlo. Es además la salida cuando se agotan los tres.
+   */
+  async update(idOrganization, idPublication, body, options = {}) {
+    return this.putOne(
+      this.path(idOrganization, idPublication),
+      "publication",
+      serializeInput(body),
+      options
+    );
+  }
+  /**
+   * Borra una publicación **y también el post en la red social**.
+   *
+   * En X borrar cuesta créditos: sin ellos devuelve un 940 en vez de un error genérico.
+   */
+  async remove(idOrganization, idPublication, options = {}) {
+    await this.httpDelete(this.path(idOrganization, idPublication), void 0, options);
+  }
+  /**
+   * Vuelve a intentar una publicación que falló, sin tocar su contenido.
+   *
+   * Se reintenta EN LA PETICIÓN, así que la respuesta ya dice si esta vez salió. Cada llamada
+   * gasta un reintento aunque vuelva a fallar por el contenido; sólo los créditos de X cortan
+   * antes de gastarlo. Una publicación que no está en `withErrors` devuelve un 949, y agotar el
+   * tope, un 950.
+   */
+  async retry(idOrganization, idPublication, options = {}) {
+    return this.httpPost(
+      `${this.path(idOrganization, idPublication)}/retry`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Pide las métricas A LA RED, en vivo, y devuelve su desglose crudo.
+   *
+   * **En X esto cuesta un crédito por lectura.** Para pintar una gráfica usa {@link stats}, que
+   * lee lo ya medido y no cuesta nada.
+   */
+  async metrics(idOrganization, idPublication, options = {}) {
+    return this.httpGet(
+      `${this.path(idOrganization, idPublication)}/metrics`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * La evolución medida de una publicación: una fila por día, más su última medición.
+   *
+   * Es lectura pura de lo guardado: mirar la gráfica no llama a la red y no cuesta créditos. Una
+   * `series` vacía es una respuesta válida —recién enviada, o una red sin estadísticas—, no un
+   * error. Cada `metrics` es el ACUMULADO a esa fecha, no el incremento del día.
+   */
+  async stats(idOrganization, idPublication, options = {}) {
+    return this.httpGet(
+      `${this.path(idOrganization, idPublication)}/stats`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Lo que hay publicado en el muro de la cuenta **según la red**, no según PlanVortex: incluye
+   * lo que se publicó por fuera.
+   *
+   * **En X cuesta un crédito por elemento leído**, así que el `limit` es dinero.
+   */
+  async listOnNetwork(idOrganization, idAccount, options = {}) {
+    return this.getList(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/accounts/${requireId(idAccount, "idAccount")}/social_publications`,
+      "publications",
+      { offset: options.offset, limit: options.limit },
+      options
+    );
+  }
+  path(idOrganization, idPublication) {
+    return `/organizations/${requireId(idOrganization, "idOrganization")}/publish/${requireId(idPublication, "idPublication")}`;
+  }
+};
+function listQuery2(options) {
+  return {
+    offset: options.offset,
+    limit: options.limit,
+    from_date: options.from_date,
+    to_date: options.to_date,
+    search: options.search,
+    //El servidor lo lee como el literal "true": un `false` no cambia nada, así que se omite.
+    orderByPublish: options.orderByPublish ? true : void 0,
+    state: options.state,
+    accounts: options.accounts,
+    social_network: options.social_network
+  };
+}
+function serializeInput(body) {
+  const { publish_date, ...rest } = body;
+  return {
+    ...rest,
+    ...publish_date === void 0 ? {} : { publish_date: typeof publish_date === "string" ? publish_date : publish_date.toISOString() }
+  };
+}
+var MIME_BY_EXTENSION = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  heic: "image/heic",
+  heif: "image/heif",
+  mp4: "video/mp4"
+};
+function guessContentType(filename) {
+  const extension = filename.split(".").pop()?.toLowerCase();
+  return extension ? MIME_BY_EXTENSION[extension] : void 0;
+}
+function isBinary(value) {
+  return value instanceof Uint8Array;
+}
+async function toFilePart(input) {
+  const { file } = input;
+  if (typeof file === "string") {
+    const filename = input.filename ?? path.basename(file);
+    const type = input.contentType ?? guessContentType(filename);
+    if (!type) {
+      throw new PlanVortexConfigError(
+        `No se puede deducir el tipo de "${filename}": pasa contentType. El servidor decide si es imagen o v\xEDdeo por el tipo que mandes, no por el contenido.`
+      );
+    }
+    return { blob: await openFileAsBlob(file, type), filename };
+  }
+  if (isBinary(file)) {
+    const filename = input.filename;
+    if (!filename) {
+      throw new PlanVortexConfigError("Un Buffer no lleva nombre: pasa filename junto al fichero.");
+    }
+    const type = input.contentType ?? guessContentType(filename);
+    if (!type) {
+      throw new PlanVortexConfigError(
+        `No se puede deducir el tipo de "${filename}": pasa contentType.`
+      );
+    }
+    return { blob: new Blob([file.slice()], { type }), filename };
+  }
+  if (file instanceof Blob) {
+    const filename = input.filename ?? (file instanceof File ? file.name : void 0);
+    if (!filename) {
+      throw new PlanVortexConfigError("Un Blob sin nombre: pasa filename junto al fichero.");
+    }
+    const type = input.contentType ?? (file.type || guessContentType(filename));
+    if (!type) {
+      throw new PlanVortexConfigError(
+        `No se puede deducir el tipo de "${filename}": pasa contentType.`
+      );
+    }
+    return { blob: file.type === type ? file : file.slice(0, file.size, type), filename };
+  }
+  throw new PlanVortexConfigError("El fichero tiene que ser una ruta, un Buffer o un Blob.");
+}
+async function buildUploadForm(input) {
+  const { blob, filename } = await toFilePart(input);
+  const form = new FormData();
+  form.append("file", blob, filename);
+  return form;
+}
+async function openFileAsBlob(path, type) {
+  const fs = await import('fs');
+  const openAsBlob = fs.openAsBlob;
+  if (typeof openAsBlob === "function") {
+    return openAsBlob(path, { type });
+  }
+  const { readFile } = await import('fs/promises');
+  return new Blob([await readFile(path)], { type });
+}
+
+// src/resources/uploads.ts
+var UploadsResource = class extends Resource {
+  /**
+   * Sube un fichero. Admite una ruta en disco, un `Buffer` o un `Blob`.
+   *
+   * La ruta es la buena para lo grande: es la única forma que no pasa el fichero por memoria.
+   *
+   * ```ts
+   * await pv.uploads.create(orgId, { file: "./hogaza.jpg" });
+   * await pv.uploads.create(orgId, { file: bytes, filename: "hogaza.jpg" });
+   * ```
+   */
+  async create(idOrganization, input, options = {}) {
+    const form = await buildUploadForm(input);
+    return this.postOne(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/uploads`,
+      "upload",
+      form,
+      options
+    );
+  }
+  /**
+   * Los ficheros de la biblioteca.
+   *
+   * No salen aquí los recortes que la plataforma se hace para sí misma (`is_temporal`) ni las
+   * portadas de vídeo, que son otro upload y viajan dentro del suyo.
+   */
+  async list(idOrganization, options = {}) {
+    return this.getList(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/uploads`,
+      "uploads",
+      { offset: options.offset, limit: options.limit },
+      options
+    );
+  }
+  /** Los ficheros de la biblioteca, encadenando páginas. */
+  iterate(idOrganization, options = {}) {
+    return iteratePages((page) => this.list(idOrganization, { ...options, ...page }), options);
+  }
+  /** Un fichero. Pídelo de nuevo cuando necesites un `public_path` vigente. */
+  async get(idOrganization, idUpload, options = {}) {
+    return this.getOne(this.path(idOrganization, idUpload), "upload", void 0, options);
+  }
+  /** Cambia la portada de un vídeo. Ojo con `cover_offset`: se escribe siempre (ver arriba). */
+  async update(idOrganization, idUpload, body, options = {}) {
+    return this.putOne(this.path(idOrganization, idUpload), "upload", body, options);
+  }
+  /**
+   * Borra un fichero.
+   *
+   * Con `force` se borra aunque una publicación siga apuntándolo; sin él, un fichero en uso se
+   * conserva y sólo se saca de la biblioteca.
+   */
+  async remove(idOrganization, idUpload, options = {}) {
+    await this.httpDelete(
+      this.path(idOrganization, idUpload),
+      options.force ? { forceDelete: true } : void 0,
+      options
+    );
+  }
+  /**
+   * Trae a la biblioteca ficheros elegidos en una integración (el selector de Drive).
+   *
+   * La respuesta es PARCIAL a propósito: mira `errors` aunque `uploads` traiga algo — de seis
+   * ficheros pueden entrar cuatro. Un `2204` significa que el proveedor no da los bytes: un
+   * documento nativo de Google no tiene fichero que descargar.
+   */
+  async import(idOrganization, idIntegration, files, options = {}) {
+    return this.httpPost(
+      `/organizations/${requireId(idOrganization, "idOrganization")}/uploads/import`,
+      { id_integration: requireId(idIntegration, "idIntegration"), files },
+      options
+    );
+  }
+  path(idOrganization, idUpload) {
+    return `/organizations/${requireId(idOrganization, "idOrganization")}/uploads/${requireId(idUpload, "idUpload")}`;
+  }
+};
+
+// src/client.ts
+function buildUserAgent() {
+  const runtime = typeof process !== "undefined" && process.versions?.node ? ` node/${process.versions.node}` : "";
+  return `planvortex-node/${VERSION}${runtime}`;
+}
+function readEnv(name) {
+  return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+function looksLikeBrowser() {
+  const maybeWindow = globalThis.window;
+  return maybeWindow !== void 0 && maybeWindow.document !== void 0;
+}
+var PlanVortex = class _PlanVortex {
+  /** Sin barra final. Útil para componer una URL a mano cuando haga falta. */
+  baseUrl;
+  /** Metadatos estáticos de las redes: qué hay, qué sabe hacer cada una y sus límites. Cacheado. */
+  catalog;
+  /** Clientes: el plan contratado y sus organizaciones raíz. */
+  clients;
+  /** Organizaciones: la ficha, las hijas, y el cupo que tienen y gastan. */
+  organizations;
+  /** Cuentas sociales conectadas. Conectar una es otra cosa: hace falta una persona (§ fase 9). */
+  accounts;
+  /** La biblioteca de ficheros de una organización. */
+  uploads;
+  /** Publicaciones: crear, programar, reintentar y medir. */
+  publications;
+  http;
+  auth;
+  options;
+  constructor(options = {}) {
+    if (looksLikeBrowser() && options.dangerouslyAllowBrowser !== true) {
+      throw new PlanVortexConfigError(
+        "planvortex es un paquete de servidor: el client_secret no puede vivir en un navegador. Para conectar una cuenta desde el front usa el temporal_connect_token."
+      );
+    }
+    this.options = options;
+    this.baseUrl = (options.baseUrl ?? readEnv("PLANVORTEX_BASE_URL") ?? PLANVORTEX_API_URL).replace(
+      /\/+$/,
+      ""
+    );
+    this.http = new HttpClient({
+      baseUrl: this.baseUrl,
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+      ...options.retry === void 0 ? {} : { retry: options.retry },
+      ...options.hooks === void 0 ? {} : { hooks: options.hooks },
+      ...options.fetch === void 0 ? {} : { fetch: options.fetch },
+      headers: { "user-agent": buildUserAgent() }
+    });
+    const clientId = options.clientId ?? readEnv("PLANVORTEX_CLIENT_ID");
+    const clientSecret = options.clientSecret ?? readEnv("PLANVORTEX_CLIENT_SECRET");
+    if (options.accessToken) {
+      this.auth = new StaticTokenAuth(options.accessToken);
+    } else if (clientId && clientSecret) {
+      this.auth = new ClientCredentialsAuth(this.http, {
+        clientId,
+        clientSecret,
+        scope: options.scope
+      });
+    } else {
+      throw new PlanVortexConfigError(
+        "Faltan credenciales: pasa clientId y clientSecret (o PLANVORTEX_CLIENT_ID y PLANVORTEX_CLIENT_SECRET en el entorno), o un accessToken."
+      );
+    }
+    this.catalog = new CatalogResource(this);
+    this.clients = new ClientsResource(this);
+    this.organizations = new OrganizationsResource(this);
+    this.accounts = new AccountsResource(this);
+    this.uploads = new UploadsResource(this);
+    this.publications = new PublicationsResource(this);
+  }
+  /**
+   * Una petición autenticada. Es lo que usarán los recursos de las fases 6 y 7; un integrador no
+   * debería necesitarla, pero está expuesta para no dejar a nadie tirado ante un endpoint que la
+   * librería aún no cubra.
+   *
+   * Reintenta **una sola vez** ante los códigos de token (501 y 522), que llegan dentro de un 400.
+   * Un token puede morir antes de su `expires_in` —un despliegue de Keycloak, la app revocada— y
+   * ese caso se arregla pidiendo otro; si el segundo también falla, el error sale.
+   */
+  async request(request) {
+    try {
+      return await this.send(request);
+    } catch (error) {
+      if (!isTokenError(error)) {
+        throw error;
+      }
+      this.auth.invalidate();
+      return this.send(request);
+    }
+  }
+  /**
+   * El mismo cliente, con la misma forma, autenticado con un token temporal de conexión.
+   *
+   * Es la pieza del flujo de conexión de cuentas (§ trampa 2): una app **no** puede conectar una
+   * cuenta de Instagram —eso es un OAuth con una persona delante—, así que emite un token
+   * temporal, se lo pasa a su usuario y con él se piden los `connect_links`. El token va atado a
+   * una sola organización: usarlo contra otra devuelve el error 1101.
+   */
+  asTemporalToken(token) {
+    return new _PlanVortex({
+      ...this.options,
+      clientId: void 0,
+      clientSecret: void 0,
+      accessToken: token,
+      baseUrl: this.baseUrl
+    });
+  }
+  async send(request) {
+    const token = await this.auth.getToken();
+    return this.http.request({
+      ...request,
+      headers: { ...request.headers, authorization: `Bearer ${token}` }
+    });
+  }
+};
+
+// src/types.ts
+function accountId(publication) {
+  const value = publication.id_account;
+  return typeof value === "string" ? value : value._id;
+}
+function account(publication) {
+  const value = publication.id_account;
+  return typeof value === "string" ? void 0 : value;
+}
+function messageDirection(message) {
+  if (message.from_contact_id) {
+    return "incoming";
+  }
+  return message.contact_id ? "outgoing" : "unknown";
+}
+function messageContactId(message) {
+  const value = message.from_contact_id ?? message.contact_id;
+  if (value === void 0) {
+    return void 0;
+  }
+  return typeof value === "string" ? value : value._id;
+}
+function messageContact(message) {
+  const value = message.from_contact_id ?? message.contact_id;
+  return value === void 0 || typeof value === "string" ? void 0 : value;
+}
+function messageFiles(message) {
+  const files = message.message_options?.files ?? [];
+  return files.filter((file) => typeof file !== "string");
+}
+function messageFileIds(message) {
+  const files = message.message_options?.files ?? [];
+  return files.map((file) => typeof file === "string" ? file : file._id);
+}
+
+exports.AccountError = AccountError;
+exports.AccountsResource = AccountsResource;
+exports.AiPlanError = AiPlanError;
+exports.AuthError = AuthError;
+exports.CatalogResource = CatalogResource;
+exports.ClientsResource = ClientsResource;
+exports.ContactError = ContactError;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+exports.DEFAULT_RETRY = DEFAULT_RETRY;
+exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+exports.FileError = FileError;
+exports.IntegrationError = IntegrationError;
+exports.MAX_PAGES = MAX_PAGES;
+exports.MessagingError = MessagingError;
+exports.NO_ERROR_CODE = NO_ERROR_CODE;
+exports.OrganizationError = OrganizationError;
+exports.OrganizationsResource = OrganizationsResource;
+exports.PLANVORTEX_API_URL = PLANVORTEX_API_URL;
+exports.PLANVORTEX_ERROR_RANGES = PLANVORTEX_ERROR_RANGES;
+exports.PlanLimitError = PlanLimitError;
+exports.PlanVortex = PlanVortex;
+exports.PlanVortexAuthenticationError = PlanVortexAuthenticationError;
+exports.PlanVortexConfigError = PlanVortexConfigError;
+exports.PlanVortexConnectionError = PlanVortexConnectionError;
+exports.PlanVortexError = PlanVortexError;
+exports.ProductError = ProductError;
+exports.PublicationError = PublicationError;
+exports.PublicationsResource = PublicationsResource;
+exports.TOKEN_ERROR_CODES = TOKEN_ERROR_CODES;
+exports.TOKEN_REFRESH_MARGIN_MS = TOKEN_REFRESH_MARGIN_MS;
+exports.UploadsResource = UploadsResource;
+exports.UserError = UserError;
+exports.VERSION = VERSION;
+exports.account = account;
+exports.accountId = accountId;
+exports.errorFamilyForCode = errorFamilyForCode;
+exports.guessContentType = guessContentType;
+exports.isPlanVortexError = isPlanVortexError;
+exports.isTokenError = isTokenError;
+exports.messageContact = messageContact;
+exports.messageContactId = messageContactId;
+exports.messageDirection = messageDirection;
+exports.messageFileIds = messageFileIds;
+exports.messageFiles = messageFiles;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map