planvortex 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,851 @@
+import { P as Paginated, S as SocialNetwork, C as ConnectLink, a as ConnectResult, E as EnableResult, A as Account, b as AccountMetrics, c as PersistentMenu, d as SocialCapabilities, e as CommentActions, f as SocialLimits, g as PublicationLimits, h as AspectRatiosByNetwork, i as Client, O as Organization, j as PlanData, k as ConnectToken, l as PublicationInput, m as Publication, n as PublicationState, o as PublicationStats, p as PublicationStatsHistory, U as Upload } from './index-CUrq0B7g.js';
+export { q as AccountError, r as AccountMetricRow, s as AccountStateChange, t as AccountWebhookChangeBase, u as AiContext, v as AiPlan, w as AiPlanError, x as ApiErrorBody, y as AspectRatios, z as AuthError, B as ClientApp, D as ClientPlan, F as Comment, G as CommentAuthor, H as CommentChange, I as CommentNetwork, J as Contact, K as ContactError, L as Conversation, M as EngagementBase, N as FileError, Q as FileFormat, R as FileProperties, T as FileType, V as Integration, W as IntegrationError, X as IntegrationErrorChange, Y as Message, Z as MessageChange, _ as MessagingError, $ as NO_ERROR_CODE, a0 as OpenApiComponents, a1 as OpenApiOperations, a2 as OpenApiPaths, a3 as OpenApiWebhooks, a4 as OpenEnum, a5 as OrganizationError, a6 as PLANVORTEX_ERROR_RANGES, a7 as PlanLimitError, a8 as PlanVortexAuthenticationError, a9 as PlanVortexConfigError, aa as PlanVortexConnectionError, ab as PlanVortexError, ac as PlanVortexErrorOptions, ad as PlanVortexErrorRange, ae as Product, af as ProductError, ag as PublicationError, ah as PublicationErrorDetail, ai as PublicationMetrics, aj as PublicationStatsPoint, ak as PublicationType, al as SocialCredentials, am as SocialLimitsMap, an as TOKEN_ERROR_CODES, ao as UnknownWebhookChange, ap as UserError, aq as WebhookAlgorithm, ar as WebhookChange, as as WebhookEvent, at as account, au as accountId, av as errorFamilyForCode, aw as isPlanVortexError, ax as isTokenError, ay as messageContact, az as messageContactId, aA as messageDirection, aB as messageFileIds, aC as messageFiles } from './index-CUrq0B7g.js';
+
+/**
+ * Las dos constantes que todo lo demás necesita. Viven aparte de `index.ts` para que `client.ts`
+ * pueda leerlas sin importar el punto de entrada, que a su vez le importa a él: el ciclo compila,
+ * pero deja el orden de inicialización en manos del bundler y eso se paga tarde y mal.
+ */
+/** La única URL que un integrador configura. El proveedor de identidad no es parte del contrato. */
+declare const PLANVORTEX_API_URL = "https://api.planvortex.com/v1.0.0";
+/**
+ * Versión del paquete, en el `User-Agent` de cada petición.
+ *
+ * Es una constante y no un `require("../package.json")` a propósito: leer el package.json en tiempo
+ * de ejecución obliga a empaquetarlo y se rompe distinto en ESM y en CJS. La mantiene sincronizada
+ * un test.
+ */
+declare const VERSION = "0.0.1";
+
+/** `fetch` con la firma que usamos. Se puede sustituir en tests o para meter un proxy. */
+type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/** Valores admitidos en la query. `undefined` y `null` se omiten; un array repite la clave. */
+type QueryValue = string | number | boolean | Date | null | undefined | readonly (string | number | boolean)[];
+interface RetryConfig {
+    /** Cuántas veces se REPITE una petición fallida. `0` desactiva los reintentos. */
+    maxRetries: number;
+    /** Espera base del backoff exponencial, en ms. La real es aleatoria entre 0 y el tope. */
+    baseDelayMs: number;
+    /**
+     * Tope de espera entre intentos, en ms.
+     *
+     * Además de recortar el backoff, decide qué hacer con un `Retry-After` largo: si el servidor
+     * pide más que esto, la librería **no** espera — lanza el error con `retryAfter` puesto y deja
+     * que el integrador decida. Un `Retry-After: 300` del freno del token endpoint no puede
+     * traducirse en una llamada que se queda cinco minutos colgada.
+     */
+    maxDelayMs: number;
+}
+declare const DEFAULT_RETRY: RetryConfig;
+/** 120 s, como el panel: subir y publicar un vídeo es lento de verdad. */
+declare const DEFAULT_TIMEOUT_MS = 120000;
+interface RequestInfo {
+    method: HttpMethod;
+    url: string;
+    /** 1 la primera vez. */
+    attempt: number;
+}
+interface ResponseInfo extends RequestInfo {
+    status: number;
+    /** Milisegundos de ese intento. */
+    durationMs: number;
+}
+interface RetryInfo extends RequestInfo {
+    /** Espera antes del siguiente intento, en ms. */
+    delayMs: number;
+    /** El status que provocó el reintento, o `undefined` si fue un fallo de red. */
+    status: number | undefined;
+    /** El error de red, si lo hubo. */
+    error: unknown;
+}
+/**
+ * Ganchos para el logger del integrador. Son síncronos a propósito: si uno lanza, lanza en su
+ * llamada, no en medio del reintento.
+ */
+interface HttpHooks {
+    onRequest?: (info: RequestInfo) => void;
+    onResponse?: (info: ResponseInfo) => void;
+    onRetry?: (info: RetryInfo) => void;
+}
+interface HttpRequest {
+    method: HttpMethod;
+    /** Empieza por `/`, relativo a `baseUrl`. */
+    path: string;
+    query?: Record<string, QueryValue>;
+    /**
+     * `FormData`, `URLSearchParams` o `string` viajan tal cual; cualquier otra cosa se serializa a
+     * JSON. `undefined` es "sin cuerpo".
+     */
+    body?: unknown;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    /** Del integrador, para cancelar. Se combina con el timeout interno. */
+    signal?: AbortSignal | undefined;
+    /**
+     * Fuerza que la petición se pueda reintentar aunque sea un POST. Sólo para POSTs que no crean
+     * nada — hoy, `POST /oauth/token`.
+     */
+    idempotent?: boolean;
+    /** `none` salta el parseo del cuerpo. Por defecto se intenta JSON. */
+    parse?: "json" | "none";
+}
+interface HttpResponse<T> {
+    data: T;
+    status: number;
+    headers: Headers;
+    /** `x-request-id`, cuando el despliegue lo pone. */
+    requestId: string | undefined;
+}
+
+/**
+ * Lo que comparten todos los recursos: una petición autenticada y el desenvuelto del sobre.
+ *
+ * Un recurso no construye su propio transporte: recibe el {@link PlanVortex} y usa su `request`,
+ * que es lo que hace que el token, los reintentos y los hooks sean unos para toda la instancia.
+ * Y no importa `client.ts` ni por el tipo — sólo la forma que necesita— porque `client.ts` sí
+ * importa los recursos, y el ciclo compilaría dejando el orden de inicialización en manos del
+ * bundler.
+ */
+
+/** Lo único que un recurso necesita del cliente. */
+interface RequestSender {
+    request<T>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+type Query = Record<string, QueryValue>;
+/** Opciones por llamada que cualquier método acepta: cancelar y ajustar el timeout. */
+interface RequestOptions {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}
+declare abstract class Resource {
+    protected readonly client: RequestSender;
+    constructor(client: RequestSender);
+    protected send<T>(request: HttpRequest, options?: RequestOptions): Promise<T>;
+    protected httpGet<T>(path: string, query?: Query, options?: RequestOptions): Promise<T>;
+    protected httpPost<T>(path: string, body?: unknown, options?: RequestOptions, query?: Query): Promise<T>;
+    protected httpPut<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    protected httpDelete<T>(path: string, query?: Query, options?: RequestOptions): Promise<T>;
+    /** `GET` de una lista, ya desenvuelta a `{data, total}`. */
+    protected getList<T>(path: string, key: string, query?: Query, options?: RequestOptions): Promise<Paginated<T>>;
+    /** `GET` de un recurso suelto, ya sacado de su sobre. */
+    protected getOne<T>(path: string, key: string, query?: Query, options?: RequestOptions): Promise<T>;
+    /** `POST` que devuelve un recurso envuelto. */
+    protected postOne<T>(path: string, key: string, body?: unknown, options?: RequestOptions, query?: Query): Promise<T>;
+    /** `PUT` que devuelve un recurso envuelto. */
+    protected putOne<T>(path: string, key: string, body?: unknown, options?: RequestOptions): Promise<T>;
+}
+
+/** Lo que admite cualquier `list()` del paquete, además de los filtros propios de su dominio. */
+interface PageOptions {
+    /** Cuántos elementos pedir. Sin él manda el servidor, que no siempre pagina igual. */
+    limit?: number | undefined;
+    /** Cuántos saltar. `0` es la primera página. */
+    offset?: number | undefined;
+}
+/** Elementos por página cuando `iterate()` no recibe `limit`. */
+declare const DEFAULT_PAGE_SIZE = 50;
+/**
+ * El seguro contra un bucle infinito. No es un límite de cuánto se puede leer: es lo que hace que
+ * un servidor que ignore el `offset` falle en vez de colgar el proceso.
+ */
+declare const MAX_PAGES = 10000;
+
+/**
+ * Cuentas sociales conectadas a una organización.
+ *
+ * DOS COSAS QUE NO SE ADIVINAN SOLAS:
+ *
+ *  - **Una app no puede CONECTAR una cuenta.** Conectar Instagram es un OAuth con una persona
+ *    delante, y las credenciales de app no valen para eso: {@link AccountsResource.connectLinks},
+ *    {@link AccountsResource.connect} y {@link AccountsResource.enable} contestan 519 si se llaman
+ *    con ellas. Se emite un token temporal
+ *    (`organizations.createConnectToken`), se le pasa a la persona, y se llaman con un cliente
+ *    autenticado con ese token: `pv.asTemporalToken(token)`.
+ *  - **`error_code` distinto de 0 es una cuenta rota**, no un fallo de esta llamada. Sigue en la
+ *    lista con sus datos, pero ni publica ni mide hasta que alguien la reconecte.
+ */
+
+/**
+ * Las capacidades por las que se puede filtrar la lista. Son las mismas que publica
+ * `catalog.socialCapabilities()`, aplicadas en el servidor: es la forma de pedir "las cuentas con
+ * las que puedo publicar" sin mantener tu propia tabla de qué red hace qué.
+ */
+type AccountCapability = "publications" | "messages" | "products" | "webhooks" | "persistent_menu" | "comments";
+interface AccountListOptions extends PageOptions {
+    /** Búsqueda libre sobre el nombre y el usuario de la cuenta. */
+    name?: string | undefined;
+    /** Sólo estas redes. */
+    social_network?: readonly SocialNetwork[] | undefined;
+    /** Sólo estas cuentas, por identificador. */
+    accounts?: readonly string[] | undefined;
+    /** Sólo las cuentas cuya red sabe hacer esto. */
+    capability?: AccountCapability | undefined;
+}
+interface AccountMetricsOptions extends RequestOptions {
+    /** Principio del rango. Por defecto, un día antes de `to_date`. */
+    from_date?: Date | string | undefined;
+    /** Final del rango. Por defecto, ahora. */
+    to_date?: Date | string | undefined;
+    /**
+     * Sólo estas métricas, por su nombre CRUDO — los que devuelve {@link AccountsResource.metricList}.
+     * Sin esto vuelven todas las medidas.
+     */
+    names?: readonly string[] | undefined;
+}
+interface ConnectLinksOptions extends RequestOptions {
+    /** Sólo estas redes. Sin esto vuelven todas las que la organización pueda conectar ahora. */
+    social_network?: readonly SocialNetwork[] | undefined;
+    /**
+     * A qué front de PlanVortex devuelve la red al usuario, para un despliegue de marca blanca.
+     *
+     * **No es una URL tuya**, y no puede serlo: las redes sólo aceptan `redirect_uri` registrados
+     * en su propia configuración de aplicación. Tiene que ser uno de los fronts que el servidor
+     * tiene dados de alta o la llamada contesta 532. A dónde vuelve TU usuario cuando termina se
+     * decide en `organizations.createConnectToken({redirect_uri})`.
+     */
+    redirect_uri?: string | undefined;
+}
+/**
+ * Lo que la red social pegó a la URL de vuelta. Se pasa **tal cual**, sin tocar ni filtrar: cada
+ * red manda lo suyo (`code` y `state` casi todas, `oauth_token`/`oauth_verifier` X, ...).
+ */
+type ConnectCallbackParams = Record<string, string | readonly string[] | undefined>;
+declare class AccountsResource 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}.
+     */
+    connectLinks(idOrganization: string, options?: ConnectLinksOptions): Promise<ConnectLink[]>;
+    /**
+     * 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.
+     */
+    connect(idOrganization: string, socialNetwork: SocialNetwork, params?: ConnectCallbackParams, options?: RequestOptions): Promise<ConnectResult>;
+    /**
+     * 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.
+     */
+    enable(idOrganization: string, idAccount: string, options?: RequestOptions): Promise<EnableResult>;
+    /** Las cuentas de una organización. */
+    list(idOrganization: string, options?: AccountListOptions & RequestOptions): Promise<Paginated<Account>>;
+    /** Las cuentas de una organización, encadenando páginas. */
+    iterate(idOrganization: string, options?: AccountListOptions & RequestOptions): AsyncGenerator<Account>;
+    /** La ficha de una cuenta. */
+    get(idOrganization: string, idAccount: string, options?: RequestOptions): Promise<Account>;
+    /** Cambia el nombre con el que la cuenta se ve en PlanVortex. Es lo único editable. */
+    update(idOrganization: string, idAccount: string, body: {
+        name?: string;
+    }, options?: RequestOptions): Promise<Account>;
+    /**
+     * Desconecta la cuenta y **borra sus publicaciones**. Lo ya publicado en la red se queda donde
+     * está: esto no la toca.
+     */
+    remove(idOrganization: string, idAccount: string, options?: RequestOptions): Promise<void>;
+    /**
+     * 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`.
+     */
+    metrics(idOrganization: string, idAccount: string, options?: AccountMetricsOptions): Promise<AccountMetrics>;
+    /**
+     * 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`).
+     */
+    metricList(idOrganization: string, idAccount: string, options?: RequestOptions): Promise<string[]>;
+    /**
+     * 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()`.
+     */
+    getPersistentMenu(idOrganization: string, idAccount: string, options?: RequestOptions): Promise<PersistentMenu>;
+    /**
+     * 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.
+     */
+    setPersistentMenu(idOrganization: string, idAccount: string, menu: PersistentMenu, options?: RequestOptions): Promise<PersistentMenu>;
+    private path;
+}
+
+/**
+ * El catálogo: qué redes hay, qué sabe hacer cada una y contra qué límites se valida.
+ *
+ * POR QUÉ SE CACHEA: son constantes del despliegue. No dependen del cliente, no dependen de la
+ * organización y no cambian entre dos llamadas — cambian cuando se despliega el servidor. Un
+ * compositor que valide el texto mientras se escribe pediría `/social_limits` en cada tecla; con la
+ * caché lo pide una vez por instancia de {@link PlanVortex}.
+ *
+ * POR QUÉ SE PIDEN Y NO SE ESCRIBEN AQUÍ: es la regla de la casa — quien valida el límite es quien
+ * lo anuncia. El panel tenía su propia tabla y divergió: contaba LinkedIn hasta 3.000 mientras el
+ * servidor lo tumbaba a los 1.300, así que el usuario escribía un texto que el contador daba por
+ * bueno y la API rechazaba. Una copia dentro de esta librería sería el mismo error un piso más
+ * abajo, y encima repartido por npm.
+ *
+ * LA CACHÉ ES POR INSTANCIA Y NO CADUCA. Un proceso de días que quiera enterarse de una red nueva
+ * llama a {@link CatalogResource.clearCache}; un proceso normal se muere antes de que importe.
+ */
+
+declare class CatalogResource extends Resource {
+    private readonly cache;
+    /**
+     * Las redes soportadas.
+     *
+     * **La lista crece varias veces al año.** No la copies a una constante tuya: pídela.
+     */
+    socialNetworks(options?: RequestOptions): Promise<SocialNetwork[]>;
+    /** Las redes que aceptan publicaciones. Ni WhatsApp ni Google Business están. */
+    allowedSocialPublications(options?: RequestOptions): Promise<SocialNetwork[]>;
+    /**
+     * 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.
+     */
+    allowedSocialMessages(options?: RequestOptions): Promise<SocialNetwork[]>;
+    /**
+     * 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.
+     */
+    socialCapabilities(options?: RequestOptions): Promise<Record<string, SocialCapabilities>>;
+    /**
+     * 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**.
+     */
+    socialCommentActions(options?: RequestOptions): Promise<Record<string, CommentActions>>;
+    /**
+     * 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.
+     */
+    socialLimits(options?: RequestOptions): Promise<SocialLimits>;
+    /** Los topes de una publicación que no dependen de la red: hoy, cuántos reintentos manuales admite. */
+    publicationLimits(options?: RequestOptions): Promise<PublicationLimits>;
+    /**
+     * 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.
+     */
+    allowedAspectRatios(options?: RequestOptions): Promise<AspectRatiosByNetwork>;
+    /** Tira la caché. Para un proceso largo que quiera enterarse de una red nueva sin reiniciar. */
+    clearCache(): void;
+    /**
+     * 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.
+     */
+    private cached;
+}
+
+/**
+ * Clientes: quien contrata el plan y a quien cuelgan las organizaciones.
+ *
+ * LO QUE HAY QUE ENTENDER DEL PLAN, porque el spec lo describía mal hasta la fase 6 y era fácil
+ * leer el campo equivocado: `client.actual_plan` es la **suscripción** (si está activa, qué plan
+ * es, cuándo acaba el periodo), y los números están dentro, en `actual_plan.plan_data`. Mirar
+ * `plan_identifier` para saber los límites es el error clásico: un plan `custom` lleva los suyos.
+ *
+ * Y el CONSUMO no viaja si no se pide: `actual_use` y `actual_asigned` sólo aparecen con
+ * `getUse: true`, porque contarlos es una agregación sobre todas las organizaciones del cliente.
+ */
+
+interface ClientListOptions extends PageOptions {
+    /** Trae también `actual_use` y `actual_asigned`. Cuesta una agregación: no lo pidas por costumbre. */
+    getUse?: boolean | undefined;
+}
+interface OrganizationListOptions extends ClientListOptions {
+    /** Búsqueda por nombre. */
+    name?: string | undefined;
+}
+/** Lo que se manda para crear una organización. `actual_plan` es el cupo que se le asigna. */
+interface OrganizationInput {
+    name: string;
+    actual_plan?: Partial<Organization["actual_plan"]> | undefined;
+}
+declare class ClientsResource extends Resource {
+    /** Los clientes que puede ver quien llama. Con credenciales de app, el suyo. */
+    list(options?: ClientListOptions & RequestOptions): Promise<Paginated<Client>>;
+    /** Los clientes, página a página, sin tener que llevar el `offset` a mano. */
+    iterate(options?: ClientListOptions & RequestOptions): AsyncGenerator<Client>;
+    /** La ficha de un cliente. */
+    get(idClient: string, options?: {
+        getUse?: boolean | undefined;
+    } & RequestOptions): Promise<Client>;
+    /** Cambia lo poco que de un cliente se puede cambiar: hoy, su nombre. */
+    update(idClient: string, body: {
+        name?: string;
+    }, options?: RequestOptions): Promise<Client>;
+    /** Las organizaciones RAÍZ de un cliente. Las hijas cuelgan de cada una. */
+    organizations(idClient: string, options?: OrganizationListOptions & RequestOptions): Promise<Paginated<Organization>>;
+    /** Las organizaciones raíz de un cliente, encadenando páginas. */
+    iterateOrganizations(idClient: string, options?: OrganizationListOptions & RequestOptions): AsyncGenerator<Organization>;
+    /** Crea una organización raíz. Lo que se le asigne se descuenta de lo que el cliente tiene. */
+    createOrganization(idClient: string, body: OrganizationInput, options?: RequestOptions): Promise<Organization>;
+    /** Cambia una organización raíz: su nombre o el cupo que tiene asignado. */
+    updateOrganization(idClient: string, idOrganization: string, body: Partial<OrganizationInput>, options?: RequestOptions): Promise<Organization>;
+    /**
+     * 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.
+     */
+    deleteOrganization(idClient: string, idOrganization: string, options?: RequestOptions): Promise<void>;
+}
+
+/**
+ * Organizaciones: el contenedor de cuentas, publicaciones y ficheros, y el que reparte el cupo.
+ *
+ * LO QUE SORPRENDE: `organization.actual_plan` es lo ASIGNADO, y **falta cuando no se le asignó
+ * nada**. Una organización sin plan propio comparte el del primer padre que tenga uno, y si no lo
+ * hay, el resto sin repartir del cliente. Así que para saber qué puede hacer de verdad no se lee
+ * `actual_plan`: se llama a {@link OrganizationsResource.limits}, que es quien resuelve la cascada.
+ */
+
+interface OrganizationOptions extends RequestOptions {
+    /** Trae también `actual_use` y `actual_asigned`. Cuesta una agregación: no lo pidas por costumbre. */
+    getUse?: boolean | undefined;
+}
+interface ChildOrganizationListOptions extends OrganizationOptions, PageOptions {
+    /** Búsqueda por nombre. */
+    name?: string | undefined;
+}
+/** Lo que se puede repartir a una organización hija. Todo son números del plan del padre. */
+type OrganizationPlanInput = Partial<PlanData>;
+interface ConnectTokenOptions extends RequestOptions {
+    /**
+     * La red que la persona va a conectar. Viaja dentro de la `url` para que el panel no vuelva a
+     * preguntarla. Sin esto, el usuario elige red al llegar.
+     */
+    social_network?: SocialNetwork | undefined;
+    /**
+     * A dónde vuelve el usuario cuando termina. Tiene que ser uno de los `redirect_urls`
+     * registrados en la app, o la llamada contesta el error 532.
+     */
+    redirect_uri?: string | undefined;
+}
+declare class OrganizationsResource extends Resource {
+    /** La ficha de una organización. */
+    get(idOrganization: string, options?: OrganizationOptions): Promise<Organization>;
+    /** Cambia el nombre de una organización o el cupo que tiene asignado. */
+    update(idOrganization: string, body: Partial<OrganizationInput>, options?: RequestOptions): Promise<Organization>;
+    /**
+     * Borra una organización **con todo lo que tiene dentro**: sus hijas, sus cuentas, sus
+     * publicaciones, sus ficheros y sus comentarios. No se deshace.
+     */
+    remove(idOrganization: string, options?: RequestOptions): Promise<void>;
+    /** Las organizaciones que cuelgan de ésta. */
+    children(idOrganization: string, options?: ChildOrganizationListOptions): Promise<Paginated<Organization>>;
+    /** Las organizaciones hijas, encadenando páginas. */
+    iterateChildren(idOrganization: string, options?: ChildOrganizationListOptions): AsyncGenerator<Organization>;
+    /** Crea una organización hija con el cupo que se le reparta del plan de ésta. */
+    createChild(idOrganization: string, body: OrganizationInput, options?: RequestOptions): Promise<Organization>;
+    /**
+     * 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`.
+     */
+    limits(idOrganization: string, options?: RequestOptions): Promise<PlanData>;
+    /**
+     * 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".
+     */
+    use(idOrganization: string, options?: RequestOptions): Promise<{
+        actual_use: PlanData | undefined;
+        actual_asigned: PlanData | undefined;
+    }>;
+    /**
+     * 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.
+     */
+    createConnectToken(idOrganization: string, options?: ConnectTokenOptions): Promise<ConnectToken>;
+}
+
+/**
+ * Publicaciones: el camino que vende `/developers`.
+ *
+ * LO QUE HAY QUE SABER ANTES DE LLAMAR A NADA DE AQUÍ:
+ *
+ *  - **Crear una publicación con contenido inválido NO da error.** El servidor la guarda en estado
+ *    `withErrors` con el motivo dentro (`publication_errors`), porque el contenido se valida contra
+ *    la red y eso no es un fallo de la petición. Un `try/catch` no basta: hay que mirar `state`.
+ *  - **Sin `publish_date` sale YA**, en la propia petición. Con fecha futura queda `ready` y la
+ *    manda el robot a su hora.
+ *  - **`files` se manda como identificadores y vuelve poblado.** Lo que llega en la respuesta son
+ *    `Upload` enteros, no ids (§ el aviso de `Publication`).
+ *  - **`id_account` cambia de forma según la operación**: aquí (crear, leer, reintentar) viene
+ *    resuelto, y en el listado y al actualizar viene como identificador. `accountId(publication)`
+ *    lo tapa.
+ *  - **Borrar una publicación la borra TAMBIÉN de la red social.** No es sólo quitarla de la
+ *    biblioteca.
+ */
+
+interface PublicationListOptions extends PageOptions {
+    /** Sólo las publicadas o creadas a partir de esta fecha, según `orderByPublish`. */
+    from_date?: Date | string | undefined;
+    /** Sólo hasta esta fecha. */
+    to_date?: Date | string | undefined;
+    /** Búsqueda de texto sobre el nombre, el texto y el título. */
+    search?: string | undefined;
+    /** Ordena y filtra por `publish_date` en vez de por `creation_date`. */
+    orderByPublish?: boolean | undefined;
+    /** Sólo estos estados. */
+    state?: readonly PublicationState[] | undefined;
+    /** Sólo estas cuentas, por identificador. */
+    accounts?: readonly string[] | undefined;
+    /** Sólo estas redes. */
+    social_network?: readonly SocialNetwork[] | undefined;
+}
+/** Lo que devuelve reintentar: la publicación tal y como quedó, y el tope que aplica el servidor. */
+interface PublicationRetryResult {
+    publication: Publication;
+    /** Reintentos manuales que admite en total. Léelo de aquí en vez de escribirlo tú. */
+    max_retries: number;
+}
+declare class PublicationsResource 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"),
+     * });
+     * ```
+     */
+    create(idOrganization: string, idAccount: string, body: PublicationInput, options?: RequestOptions): Promise<Publication>;
+    /** Una publicación, con sus ficheros y su cuenta ya resueltos. */
+    get(idOrganization: string, idPublication: string, options?: RequestOptions): Promise<Publication>;
+    /** Las publicaciones de una organización. */
+    list(idOrganization: string, options?: PublicationListOptions & RequestOptions): Promise<Paginated<Publication>>;
+    /** Las publicaciones de una organización, encadenando páginas. */
+    iterate(idOrganization: string, options?: PublicationListOptions & RequestOptions): AsyncGenerator<Publication>;
+    /** Las publicaciones de UNA cuenta. Mismos filtros que {@link list}. */
+    listByAccount(idOrganization: string, idAccount: string, options?: PublicationListOptions & RequestOptions): Promise<Paginated<Publication>>;
+    /**
+     * 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.
+     */
+    update(idOrganization: string, idPublication: string, body: Partial<PublicationInput>, options?: RequestOptions): Promise<Publication>;
+    /**
+     * 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.
+     */
+    remove(idOrganization: string, idPublication: string, options?: RequestOptions): Promise<void>;
+    /**
+     * 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.
+     */
+    retry(idOrganization: string, idPublication: string, options?: RequestOptions): Promise<PublicationRetryResult>;
+    /**
+     * 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.
+     */
+    metrics(idOrganization: string, idPublication: string, options?: RequestOptions): Promise<PublicationStats>;
+    /**
+     * 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.
+     */
+    stats(idOrganization: string, idPublication: string, options?: RequestOptions): Promise<PublicationStatsHistory>;
+    /**
+     * 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.
+     */
+    listOnNetwork(idOrganization: string, idAccount: string, options?: PageOptions & RequestOptions): Promise<Paginated<Publication>>;
+    private path;
+}
+
+/**
+ * Un fichero, en cualquiera de las formas en que un integrador lo tiene a mano.
+ *
+ * La ruta es la buena para lo grande: es la única que no pasa por memoria.
+ */
+type FileSource = string | Buffer | Uint8Array | Blob;
+interface FileInput {
+    /** Ruta en disco, `Buffer` o `Blob`. */
+    file: FileSource;
+    /**
+     * Nombre con el que se guarda. Con una ruta se deduce del último tramo; con un `Buffer` es
+     * obligatorio, porque no hay de dónde sacarlo.
+     */
+    filename?: string | undefined;
+    /**
+     * MIME de la parte. Se deduce de la extensión; pásalo cuando el nombre no la tenga o mienta.
+     * Es lo que decide `file_type` y `file_format` en el servidor.
+     */
+    contentType?: string | undefined;
+}
+/** El MIME que le corresponde a un nombre de fichero, o `undefined` si la extensión no se conoce. */
+declare function guessContentType(filename: string): string | undefined;
+
+/**
+ * La biblioteca de ficheros de una organización: lo que se adjunta a una publicación.
+ *
+ * TRES AVISOS QUE AHORRAN UNA TARDE:
+ *
+ *  1. **`public_path` caduca.** Es una URL firmada, no un enlace permanente: se mantiene idéntica
+ *     dentro de la misma hora —cachearla ese rato es correcto— y después deja de servir.
+ *     Guardarla en tu base de datos es el error clásico; a los tres días están todas rotas.
+ *  2. **El tipo lo decide el `content-type` que mandes**, no el contenido ni la extensión. La
+ *     librería lo deduce del nombre; si el nombre no lleva extensión, pásalo (§ `core/files.ts`).
+ *  3. **Los topes son del servidor**: 5 MB por imagen y 200 MB por vídeo, más la cuota de espacio
+ *     de la organización. Los tres se comprueban contra los bytes que llegan de verdad, así que un
+ *     fichero grande falla a mitad de subida con un 802, un 803 o un 804 — no antes de empezar.
+ */
+
+/** Un fichero de una integración que se quiere traer a la biblioteca. */
+interface ImportFileInput {
+    /** Identificador del fichero en el proveedor (el id del fichero en Drive). */
+    external_id: string;
+    /** Nombre que enseñó el selector. Se usa para el nombre visible y para decir cuál falló. */
+    name?: string | undefined;
+    /** Tipo que declaró el selector. Sirve para rechazar pronto; manda el tipo real del cuerpo. */
+    mime_type?: string | undefined;
+}
+/** Lo que NO entró en una importación, fichero a fichero. */
+interface ImportError {
+    external_id?: string;
+    name?: string;
+    code: number;
+    message: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * El resultado de una importación, que es PARCIAL a propósito: `uploads` con lo que entró y
+ * `errors` con lo que no, para poder decir cuál de los seis ficheros elegidos falló y por qué.
+ */
+interface ImportResult {
+    uploads: Upload[];
+    errors: ImportError[];
+}
+/** Los ajustes de portada de un vídeo. Lo único que un upload deja cambiar. */
+interface UploadUpdate {
+    /**
+     * Identificador de OTRO upload, que tiene que ser una imagen, para usarlo de portada.
+     * Reemplazar una portada borra la anterior.
+     */
+    cover_image?: string | undefined;
+    /**
+     * Momento del vídeo, en milisegundos, que se usa de fotograma de portada.
+     *
+     * CUIDADO: **se escribe siempre**, así que omitirlo borra el valor guardado. Si sólo quieres
+     * cambiar `cover_image`, manda también el `cover_offset` que ya tenía.
+     */
+    cover_offset?: number | undefined;
+}
+declare class UploadsResource 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" });
+     * ```
+     */
+    create(idOrganization: string, input: FileInput, options?: RequestOptions): Promise<Upload>;
+    /**
+     * 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.
+     */
+    list(idOrganization: string, options?: PageOptions & RequestOptions): Promise<Paginated<Upload>>;
+    /** Los ficheros de la biblioteca, encadenando páginas. */
+    iterate(idOrganization: string, options?: PageOptions & RequestOptions): AsyncGenerator<Upload>;
+    /** Un fichero. Pídelo de nuevo cuando necesites un `public_path` vigente. */
+    get(idOrganization: string, idUpload: string, options?: RequestOptions): Promise<Upload>;
+    /** Cambia la portada de un vídeo. Ojo con `cover_offset`: se escribe siempre (ver arriba). */
+    update(idOrganization: string, idUpload: string, body: UploadUpdate, options?: RequestOptions): Promise<Upload>;
+    /**
+     * 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.
+     */
+    remove(idOrganization: string, idUpload: string, options?: {
+        force?: boolean | undefined;
+    } & RequestOptions): Promise<void>;
+    /**
+     * 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.
+     */
+    import(idOrganization: string, idIntegration: string, files: readonly ImportFileInput[], options?: RequestOptions): Promise<ImportResult>;
+    private path;
+}
+
+interface PlanVortexOptions {
+    /** El identificador de la app de cliente. Por defecto, `process.env.PLANVORTEX_CLIENT_ID`. */
+    clientId?: string | undefined;
+    /** El secreto de la app. Por defecto, `process.env.PLANVORTEX_CLIENT_SECRET`. */
+    clientSecret?: string | undefined;
+    /**
+     * Un token ya emitido, en vez de credenciales: el `temporal_connect_token` con el que una
+     * persona conecta su cuenta social. No se refresca solo (§ trampa 2 del roadmap).
+     */
+    accessToken?: string | undefined;
+    /** Por defecto `https://api.planvortex.com/v1.0.0`. Sin barra final. */
+    baseUrl?: string | undefined;
+    /** Timeout por petición. 120 s por defecto: publicar un vídeo es lento. */
+    timeoutMs?: number | undefined;
+    retry?: Partial<RetryConfig> | undefined;
+    /** `onRequest` / `onResponse` / `onRetry`, para enchufar el logger de casa. */
+    hooks?: HttpHooks | undefined;
+    /** `fetch` alternativo: un proxy, un mock, una implementación instrumentada. */
+    fetch?: FetchLike | undefined;
+    /** `scope` opcional del `client_credentials`. Casi nadie lo necesita. */
+    scope?: string | undefined;
+    /**
+     * Deja construir el cliente en un navegador. **No lo pongas.** El `client_credentials` exige el
+     * `client_secret`, y un secreto en un bundle de front es la cuenta entera regalada
+     * (§ trampa 9). Para el navegador existe el token temporal de conexión.
+     */
+    dangerouslyAllowBrowser?: boolean | undefined;
+}
+declare class PlanVortex {
+    /** Sin barra final. Útil para componer una URL a mano cuando haga falta. */
+    readonly baseUrl: string;
+    /** Metadatos estáticos de las redes: qué hay, qué sabe hacer cada una y sus límites. Cacheado. */
+    readonly catalog: CatalogResource;
+    /** Clientes: el plan contratado y sus organizaciones raíz. */
+    readonly clients: ClientsResource;
+    /** Organizaciones: la ficha, las hijas, y el cupo que tienen y gastan. */
+    readonly organizations: OrganizationsResource;
+    /** Cuentas sociales conectadas. Conectar una es otra cosa: hace falta una persona (§ fase 9). */
+    readonly accounts: AccountsResource;
+    /** La biblioteca de ficheros de una organización. */
+    readonly uploads: UploadsResource;
+    /** Publicaciones: crear, programar, reintentar y medir. */
+    readonly publications: PublicationsResource;
+    private readonly http;
+    private readonly auth;
+    private readonly options;
+    constructor(options?: PlanVortexOptions);
+    /**
+     * 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.
+     */
+    request<T>(request: HttpRequest): Promise<HttpResponse<T>>;
+    /**
+     * 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: string): PlanVortex;
+    private send;
+}
+
+/** Lo que devuelve `POST /oauth/token`. Ni `refresh_token` ni `id_token`: no existen aquí. */
+interface ClientCredentialsToken {
+    access_token: string;
+    token_type: string;
+    /** Segundos de vida. Keycloak da 300 hoy, pero es dato del servidor: nunca se asume. */
+    expires_in: number;
+    scope?: string;
+}
+/**
+ * De dónde sale el `Authorization` de cada petición. Dos implementaciones: las credenciales de app
+ * ({@link ClientCredentialsAuth}) y el token temporal de conexión ({@link StaticTokenAuth}).
+ */
+interface AuthProvider {
+    /** El token a poner en `Authorization: Bearer`. Pide uno nuevo si hace falta. */
+    getToken(): Promise<string>;
+    /** Tira el token cacheado. Lo llama el cliente cuando el servidor responde 501 o 522. */
+    invalidate(): void;
+}
+/** Margen con el que se pide un token nuevo antes de que caduque el que hay. */
+declare const TOKEN_REFRESH_MARGIN_MS = 60000;
+
+export { Account, type AccountCapability, type AccountListOptions, AccountMetrics, type AccountMetricsOptions, AccountsResource, AspectRatiosByNetwork, type AuthProvider, CatalogResource, type ChildOrganizationListOptions, Client, type ClientCredentialsToken, type ClientListOptions, ClientsResource, CommentActions, type ConnectCallbackParams, ConnectLink, type ConnectLinksOptions, ConnectResult, ConnectToken, type ConnectTokenOptions, DEFAULT_PAGE_SIZE, DEFAULT_RETRY, DEFAULT_TIMEOUT_MS, EnableResult, type FetchLike, type FileInput, type FileSource, type HttpHooks, type HttpMethod, type HttpRequest, type HttpResponse, type ImportError, type ImportFileInput, type ImportResult, MAX_PAGES, Organization, type OrganizationInput, type OrganizationListOptions, type OrganizationOptions, type OrganizationPlanInput, OrganizationsResource, PLANVORTEX_API_URL, type PageOptions, Paginated, PersistentMenu, PlanData, PlanVortex, type PlanVortexOptions, Publication, PublicationInput, PublicationLimits, type PublicationListOptions, type PublicationRetryResult, PublicationState, PublicationStats, PublicationStatsHistory, PublicationsResource, type RequestInfo, type RequestOptions, type ResponseInfo, type RetryConfig, type RetryInfo, SocialCapabilities, SocialLimits, SocialNetwork, TOKEN_REFRESH_MARGIN_MS, Upload, type UploadUpdate, UploadsResource, VERSION, guessContentType };