@adeli/sdk 0.0.0-stage → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,878 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+
+// src/core/duration.ts
+var MAX_TIMER_DURATION_MS = 2147483647;
+function isRepresentableTimerDuration(value) {
+  return Number.isFinite(value) && value > 0 && value <= MAX_TIMER_DURATION_MS;
+}
+
+// src/core/errors.ts
+var permissionProviders = /* @__PURE__ */ new Set(["instagram", "tiktok", "facebook", "whatsapp", "youtube", "x", "bluesky"]);
+var permissionLists = ["requiredPermissions", "missingPermissions", "requiredResources", "missingResources"];
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function provider(value) {
+  return typeof value === "string" && permissionProviders.has(value);
+}
+function descriptor(value) {
+  return record(value) && typeof value.code === "string" && typeof value.label === "string";
+}
+function isPermissionRequiredDetails(value) {
+  try {
+    if (!record(value)) return false;
+    const known = /* @__PURE__ */ new Set(["provider", "accountId", "profileId", "capability", "reconnect", ...permissionLists]);
+    if (!Object.keys(value).some((key) => known.has(key))) return false;
+    for (const key of ["accountId", "profileId", "capability"]) if (key in value && typeof value[key] !== "string") return false;
+    if ("provider" in value && !provider(value.provider)) return false;
+    for (const key of permissionLists) {
+      if (key in value) {
+        const entries = value[key];
+        if (!Array.isArray(entries)) return false;
+        for (const entry of entries) if (!descriptor(entry)) return false;
+      }
+    }
+    if ("reconnect" in value) {
+      const reconnect = value.reconnect;
+      if (!record(reconnect) || reconnect.action !== "restart_oauth") return false;
+      if ("method" in reconnect && reconnect.method !== "POST") return false;
+      if ("href" in reconnect && reconnect.href !== null && typeof reconnect.href !== "string") return false;
+      if ("provider" in reconnect && !provider(reconnect.provider)) return false;
+      if ("message" in reconnect && typeof reconnect.message !== "string") return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+var AdeliError = class extends Error {
+  name = "AdeliError";
+  constructor(message) {
+    super(message);
+  }
+};
+var ConfigurationError = class extends AdeliError {
+  name = "ConfigurationError";
+};
+var NetworkError = class extends AdeliError {
+  name = "NetworkError";
+};
+var RedirectError = class extends NetworkError {
+  name = "RedirectError";
+};
+var TimeoutError = class extends AdeliError {
+  name = "TimeoutError";
+};
+var CancellationError = class extends AdeliError {
+  name = "CancellationError";
+};
+var MalformedResponseError = class extends AdeliError {
+  name = "MalformedResponseError";
+};
+var AdeliApiError = class extends AdeliError {
+  name = "AdeliApiError";
+  status;
+  code;
+  details;
+  headers;
+  constructor(message, options) {
+    super(message);
+    this.status = options.status;
+    this.code = options.code ?? "api_error";
+    this.details = options.details;
+    this.headers = options.headers ?? new Headers();
+  }
+};
+var AuthenticationError = class extends AdeliApiError {
+  name = "AuthenticationError";
+};
+var ValidationError = class extends AdeliApiError {
+  name = "ValidationError";
+};
+var RateLimitError = class extends AdeliApiError {
+  name = "RateLimitError";
+};
+var PermissionRequiredError = class extends AdeliApiError {
+  name = "PermissionRequiredError";
+};
+function isAdeliApiError(error) {
+  return error instanceof AdeliApiError;
+}
+var VALIDATION_CODES = /* @__PURE__ */ new Set(["invalid_request", "invalid_profile", "invalid_redirect_uri"]);
+var PERMISSION_CODES = /* @__PURE__ */ new Set(["permission_required"]);
+var RATE_LIMIT_CODES = /* @__PURE__ */ new Set(["rate_limited", "rate_limit_exceeded", "quota_exhausted", "daily_quota_exceeded"]);
+function apiError(message, options) {
+  if (options.status === 401 || options.code === "unauthorized") return new AuthenticationError(message, options);
+  if (options.status === 429 || options.code !== void 0 && RATE_LIMIT_CODES.has(options.code)) return new RateLimitError(message, options);
+  if (options.code !== void 0 && PERMISSION_CODES.has(options.code)) return new PermissionRequiredError(message, options);
+  if (options.code !== void 0 && VALIDATION_CODES.has(options.code)) return new ValidationError(message, options);
+  return new AdeliApiError(message, options);
+}
+
+// src/core/config.ts
+var DEFAULT_BASE_URL = "https://app.tryadeli.com";
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function resolveConfig(options = {}) {
+  if (typeof window !== "undefined") throw new ConfigurationError("Adeli is a server-side SDK and cannot run in a browser");
+  const apiKey = options.apiKey ?? process.env.ADELI_API_KEY;
+  if (!apiKey || apiKey.trim() === "") throw new ConfigurationError("An Adeli API key is required (pass apiKey or set ADELI_API_KEY)");
+  if (/[\u0000-\u001f\u007f]/.test(apiKey)) throw new ConfigurationError("The Adeli API key must not contain control characters");
+  try {
+    new Headers({ authorization: `Bearer ${apiKey}` });
+  } catch {
+    throw new ConfigurationError("The Adeli API key must be a valid HTTP header value");
+  }
+  const baseURL = validateBaseURL(options.baseURL ?? DEFAULT_BASE_URL);
+  const timeoutMs = options.timeoutMs;
+  const maxRetries = options.maxRetries ?? 0;
+  if (timeoutMs !== void 0 && !isRepresentableTimerDuration(timeoutMs)) throw new ConfigurationError(`timeoutMs must be a positive finite number no greater than ${MAX_TIMER_DURATION_MS}ms`);
+  if (!Number.isInteger(maxRetries) || maxRetries < 0) throw new ConfigurationError("maxRetries must be a non-negative integer");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (!fetchImpl) throw new ConfigurationError("A fetch implementation is required");
+  return { apiKey, baseURL, timeoutMs, maxRetries, fetch: fetchImpl };
+}
+function validateBaseURL(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new ConfigurationError("baseURL must be an absolute URL origin");
+  }
+  if (!["http:", "https:"].includes(url.protocol)) throw new ConfigurationError("baseURL must use http or https");
+  if (url.protocol !== "https:" && !LOCAL_HOSTS.has(url.hostname)) throw new ConfigurationError("HTTPS is required except for local development");
+  if (url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") throw new ConfigurationError("baseURL must be an origin without a path, query, fragment, or credentials");
+  return url.origin;
+}
+
+// src/core/retry.ts
+var TRANSIENT_STATUSES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+function isRetryableStatus(status) {
+  return TRANSIENT_STATUSES.has(status);
+}
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - now) : void 0;
+}
+function canRetry(operation, idempotencyKey) {
+  return operation.retry === "safe-read" || operation.retry === "profile-create" && idempotencyKey !== void 0 && idempotencyKey.trim() !== "";
+}
+function backoffMs(attempt, retryAfter, random = Math.random()) {
+  if (retryAfter !== void 0) return retryAfter;
+  return Math.min(3e4, 250 * 2 ** attempt) + Math.floor(random * 100);
+}
+async function sleepWithSignal(ms, signal) {
+  if (signal.aborted) throw new CancellationError("The Adeli request was cancelled");
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => finish(() => reject(new CancellationError("The Adeli request was cancelled")));
+    const timer = setTimeout(() => finish(resolve), ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function retryableNetworkError(error) {
+  return error instanceof NetworkError && !(error instanceof RedirectError);
+}
+function isDailyQuotaExhausted(code) {
+  const normalized = code.toLowerCase().replace(/[-\s]/g, "_");
+  return normalized === "quota_exhausted" || normalized === "daily_quota_exceeded" || normalized.includes("daily") && normalized.includes("quota");
+}
+
+// src/core/transport.ts
+function isMultipartBody(value) {
+  return value !== null && typeof value === "object" && "stream" in value && "contentType" in value && typeof value.stream === "object" && typeof value.contentType === "string";
+}
+function pathSegment(value, name) {
+  const segment = String(value);
+  let decoded = segment;
+  try {
+    decoded = decodeURIComponent(segment);
+  } catch {
+  }
+  if (decoded === "." || decoded === "..") throw new TypeError(`Invalid path parameter ${name}: dot segments are not allowed`);
+  return encodeURIComponent(segment);
+}
+function buildURL(baseURL, template, path, query) {
+  const pathValues = path;
+  const rendered = template.replace(/\{([^}]+)\}/g, (_whole, name) => {
+    const value = pathValues?.[name];
+    if (value === void 0) throw new TypeError(`Missing path parameter: ${name}`);
+    return pathSegment(value, name);
+  });
+  const url = new URL(`/api/v1${rendered.startsWith("/") ? rendered : `/${rendered}`}`, `${baseURL}/`);
+  if (query) for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    if (/\u0000|\r|\n/.test(key)) throw new TypeError("Invalid query parameter name");
+    for (const item of Array.isArray(value) ? value : [value]) url.searchParams.append(key, String(item));
+  }
+  return url;
+}
+function redact(value, secret) {
+  if (typeof value === "string") return value.split(secret).join("[REDACTED]");
+  if (Array.isArray(value)) return value.map((item) => redact(item, secret));
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key.split(secret).join("[REDACTED]"), redact(item, secret)]));
+  }
+  return value;
+}
+async function readResponseText(response, signal) {
+  if (response.status === 204) return "";
+  if (signal.aborted) throw new DOMException("aborted", "AbortError");
+  const body = response.body;
+  if (!body) return "";
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const chunks = [];
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => {
+      void reader.cancel().catch(() => void 0);
+      finish(() => reject(new DOMException("aborted", "AbortError")));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    const read = async () => {
+      try {
+        while (!settled) {
+          const chunk = await reader.read();
+          if (settled) return;
+          if (chunk.done) {
+            finish(() => resolve(chunks.join("") + decoder.decode()));
+            return;
+          }
+          chunks.push(decoder.decode(chunk.value, { stream: true }));
+        }
+      } catch (error) {
+        finish(() => reject(error));
+      }
+    };
+    void read();
+  });
+}
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /** Prevent client configuration, especially apiKey, from leaking through JSON serialization. */
+  toJSON() {
+    return {};
+  }
+  /** Send raw bytes to a one-object presigned URL without leaking the Adeli API key. */
+  async upload(url, method, headers, body, options = {}) {
+    const timeoutMs = options.timeoutMs ?? this.config.timeoutMs ?? 6e4;
+    if (!isRepresentableTimerDuration(timeoutMs)) throw new TypeError(`timeoutMs must be a positive finite number no greater than ${MAX_TIMER_DURATION_MS}ms`);
+    if (options.signal?.aborted) throw new CancellationError("The media upload was cancelled");
+    const controller = new AbortController();
+    let timedOut = false;
+    let cancelled = false;
+    const onAbort = () => {
+      cancelled = true;
+      controller.abort();
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    try {
+      for (let attempt = 0; ; attempt += 1) {
+        try {
+          const response = await this.config.fetch(url, { method, headers: new Headers(headers), body, signal: controller.signal, redirect: "error" });
+          if (response.redirected) throw new RedirectError("Adeli refused a media upload redirect");
+          if (response.ok) return;
+          if (attempt < this.config.maxRetries && response.status >= 500) {
+            await sleepWithSignal(backoffMs(attempt, parseRetryAfter(response.headers.get("retry-after"))), controller.signal);
+            continue;
+          }
+          throw new NetworkError(`Direct media upload failed with status ${response.status}`);
+        } catch (error) {
+          if (timedOut) throw new TimeoutError(`Media upload exceeded its ${timeoutMs}ms deadline`);
+          if (cancelled || error instanceof Error && error.name === "AbortError") throw new CancellationError("The media upload was cancelled");
+          if (attempt < this.config.maxRetries && retryableNetworkError(error)) {
+            await sleepWithSignal(backoffMs(attempt), controller.signal);
+            continue;
+          }
+          throw error;
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async request(request) {
+    const timeoutMs = request.timeoutMs ?? this.config.timeoutMs ?? request.operation.defaultTimeoutMs ?? 6e4;
+    if (!isRepresentableTimerDuration(timeoutMs)) throw new TypeError(`timeoutMs must be a positive finite number no greater than ${MAX_TIMER_DURATION_MS}ms`);
+    if (request.idempotencyKey !== void 0 && (request.idempotencyKey.trim() === "" || /[\u0000-\u001f\u007f\r\n]/.test(request.idempotencyKey))) {
+      throw new TypeError("idempotencyKey must be a nonblank valid HTTP header value");
+    }
+    if (request.signal?.aborted) throw new CancellationError("The Adeli request was cancelled");
+    const deadline = Date.now() + timeoutMs;
+    const controller = new AbortController();
+    let timedOut = false;
+    let cancelled = false;
+    const onAbort = () => {
+      cancelled = true;
+      controller.abort();
+    };
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    try {
+      const maxAttempts = canRetry(request.operation, request.idempotencyKey) ? this.config.maxRetries + 1 : 1;
+      let attempt = 0;
+      while (true) {
+        try {
+          const response = await this.perform(request, controller.signal);
+          if (response.ok) return { data: response.data, status: response.status, headers: response.headers };
+          if (attempt + 1 < maxAttempts && isRetryableStatus(response.status) && !isDailyQuotaExhausted(response.error.code) && Date.now() < deadline) {
+            const delay = backoffMs(attempt, parseRetryAfter(response.headers.get("retry-after")));
+            if (Date.now() + delay >= deadline) throw response.error;
+            await sleepWithSignal(delay, controller.signal);
+            attempt++;
+            continue;
+          }
+          throw response.error;
+        } catch (error) {
+          if (timedOut) throw new TimeoutError(`Adeli request exceeded its ${timeoutMs}ms deadline; the remote write outcome may be unknown`);
+          if (cancelled) throw new CancellationError("The Adeli request was cancelled");
+          if (error instanceof Error && error.name === "AbortError") throw new CancellationError("The Adeli request was cancelled");
+          if (attempt + 1 < maxAttempts && retryableNetworkError(error) && Date.now() < deadline) {
+            const delay = backoffMs(attempt);
+            if (Date.now() + delay >= deadline) throw error;
+            await sleepWithSignal(delay, controller.signal);
+            attempt++;
+            continue;
+          }
+          throw error;
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async perform(request, signal) {
+    const url = buildURL(this.config.baseURL, request.operation.path, request.path, request.query);
+    const headers = new Headers({ authorization: `Bearer ${this.config.apiKey}`, accept: "application/json" });
+    let encodedBody;
+    let duplex;
+    if (request.body !== void 0) {
+      if (isMultipartBody(request.body)) {
+        encodedBody = request.body.stream;
+        headers.set("content-type", request.body.contentType);
+        duplex = "half";
+      } else if (typeof FormData !== "undefined" && request.body instanceof FormData) encodedBody = request.body;
+      else if (typeof Blob !== "undefined" && request.body instanceof Blob) encodedBody = request.body;
+      else {
+        headers.set("content-type", "application/json");
+        encodedBody = JSON.stringify(request.body);
+      }
+    }
+    if (request.idempotencyKey !== void 0) headers.set("idempotency-key", request.idempotencyKey);
+    let response;
+    try {
+      response = await this.config.fetch(url, { method: request.operation.method, headers, signal, redirect: "error", ...encodedBody === void 0 ? {} : { body: encodedBody }, ...duplex === void 0 ? {} : { duplex } });
+    } catch (error) {
+      if (signal.aborted || error instanceof Error && error.name === "AbortError") throw error;
+      throw new NetworkError("Unable to connect to Adeli");
+    }
+    if (response.redirected) throw new RedirectError("Adeli refused a redirect");
+    let text;
+    try {
+      text = await readResponseText(response, signal);
+    } catch (error) {
+      if (signal.aborted || error instanceof Error && error.name === "AbortError") throw error;
+      throw new NetworkError("Unable to read the Adeli response");
+    }
+    let data;
+    if (response.status !== 204) {
+      if (text === "") {
+        if (response.ok) throw new MalformedResponseError("Adeli returned an empty response where JSON was required");
+      } else {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          if (response.ok) throw new MalformedResponseError("Adeli returned malformed JSON");
+          data = text;
+        }
+      }
+    }
+    if (!response.ok) {
+      const envelope = data !== null && typeof data === "object" && !Array.isArray(data) ? data.error : void 0;
+      const errorBody = envelope !== null && typeof envelope === "object" && !Array.isArray(envelope) ? envelope : void 0;
+      const code = typeof errorBody?.code === "string" ? errorBody.code : void 0;
+      const redactedCode = code === void 0 ? void 0 : String(redact(code, this.config.apiKey));
+      const message = typeof errorBody?.message === "string" ? errorBody.message : `Adeli request failed with status ${response.status}`;
+      const hasDetails = errorBody !== void 0 && Object.prototype.hasOwnProperty.call(errorBody, "details");
+      const details = hasDetails ? errorBody.details : redact(data, this.config.apiKey);
+      return {
+        ok: false,
+        data: void 0,
+        status: response.status,
+        headers: response.headers,
+        error: apiError(String(redact(message, this.config.apiKey)), { status: response.status, details: redact(details, this.config.apiKey), headers: response.headers, ...redactedCode === void 0 ? {} : { code: redactedCode } })
+      };
+    }
+    return { ok: true, data: response.status === 204 ? void 0 : data, status: response.status, headers: response.headers };
+  }
+};
+
+// src/operations.ts
+var operations = {
+  getMe: { operationId: "getMe", method: "GET", path: "/me", retry: "safe-read" },
+  listProfiles: { operationId: "listProfiles", method: "GET", path: "/profiles", retry: "safe-read" },
+  createProfile: { operationId: "createProfile", method: "POST", path: "/profiles", retry: "profile-create" },
+  getProfile: { operationId: "getProfile", method: "GET", path: "/profiles/{profileId}", retry: "safe-read" },
+  updateProfile: { operationId: "updateProfile", method: "PUT", path: "/profiles/{profileId}", retry: "never" },
+  deleteProfile: { operationId: "deleteProfile", method: "DELETE", path: "/profiles/{profileId}", retry: "never" },
+  startConnection: { operationId: "startConnection", method: "POST", path: "/profiles/{profileId}/connect", retry: "never" },
+  getConnection: { operationId: "getConnection", method: "GET", path: "/profiles/{profileId}/connect/{connectionSessionId}", retry: "safe-read" },
+  listAccounts: { operationId: "listAccounts", method: "GET", path: "/accounts", retry: "safe-read" },
+  listProfileAccounts: { operationId: "listProfileAccounts", method: "GET", path: "/profiles/{profileId}/accounts", retry: "safe-read" },
+  getAccount: { operationId: "getAccount", method: "GET", path: "/profiles/{profileId}/accounts/{accountId}", retry: "safe-read" },
+  updateAccount: { operationId: "updateAccount", method: "PATCH", path: "/profiles/{profileId}/accounts/{accountId}", retry: "never" },
+  disconnectAccount: { operationId: "disconnectAccount", method: "DELETE", path: "/profiles/{profileId}/accounts/{accountId}", retry: "never" },
+  refreshAccounts: { operationId: "refreshAccounts", method: "POST", path: "/profiles/{profileId}/accounts/refresh", retry: "never" },
+  listPosts: { operationId: "listPosts", method: "GET", path: "/posts", retry: "never" },
+  createMediaUploads: { operationId: "createMediaUploads", method: "POST", path: "/media/uploads", retry: "never" },
+  createPost: { operationId: "createPost", method: "POST", path: "/posts", retry: "never", defaultTimeoutMs: 3e5 },
+  uploadYouTubeVideo: { operationId: "uploadYouTubeVideo", method: "POST", path: "/posts/youtube", retry: "never", defaultTimeoutMs: 3e5 },
+  deleteXPost: { operationId: "deleteXPost", method: "DELETE", path: "/posts/x/{postId}", retry: "never" },
+  deleteBlueskyPost: { operationId: "deleteBlueskyPost", method: "DELETE", path: "/posts/bluesky/{postId}", retry: "never" },
+  getInstagramPostStatus: { operationId: "getInstagramPostStatus", method: "GET", path: "/posts/instagram/status", retry: "safe-read" },
+  getFacebookPostStatus: { operationId: "getFacebookPostStatus", method: "GET", path: "/posts/facebook/status", retry: "safe-read" },
+  getTikTokPostStatus: { operationId: "getTikTokPostStatus", method: "GET", path: "/posts/tiktok/status", retry: "safe-read" },
+  getTikTokCreatorInfo: { operationId: "getTikTokCreatorInfo", method: "GET", path: "/posts/tiktok/creator-info", retry: "safe-read" },
+  getYouTubeVideoStatus: { operationId: "getYouTubeVideoStatus", method: "GET", path: "/posts/youtube/status", retry: "safe-read" },
+  listComments: { operationId: "listComments", method: "GET", path: "/comments", retry: "safe-read" },
+  createComment: { operationId: "createComment", method: "POST", path: "/comments", retry: "never" },
+  updateComment: { operationId: "updateComment", method: "PATCH", path: "/comments/{commentId}", retry: "never" },
+  deleteComment: { operationId: "deleteComment", method: "DELETE", path: "/comments/{commentId}", retry: "never" },
+  listMessages: { operationId: "listMessages", method: "GET", path: "/messages", retry: "safe-read" },
+  sendMessage: { operationId: "sendMessage", method: "POST", path: "/messages", retry: "never" },
+  sendInstagramMessage: { operationId: "sendInstagramMessage", method: "POST", path: "/messages/instagram", retry: "never" },
+  getInstagramAccountInsights: { operationId: "getInstagramAccountInsights", method: "GET", path: "/analytics/instagram/account-insights", retry: "safe-read" },
+  getFacebookPageMetrics: { operationId: "getFacebookPageMetrics", method: "GET", path: "/analytics/facebook/page-metrics", retry: "safe-read" },
+  getTikTokAccountAnalytics: { operationId: "getTikTokAccountAnalytics", method: "GET", path: "/analytics/tiktok/account-analytics", retry: "safe-read" },
+  getTikTokAccountInsights: { operationId: "getTikTokAccountInsights", method: "GET", path: "/analytics/tiktok/account-insights", retry: "safe-read" },
+  getTikTokVideoInsights: { operationId: "getTikTokVideoInsights", method: "GET", path: "/analytics/tiktok/video-insights", retry: "safe-read" },
+  getYouTubeChannelInsights: { operationId: "getYouTubeChannelInsights", method: "GET", path: "/analytics/youtube/channel-insights", retry: "safe-read" },
+  getYouTubeVideoInsights: { operationId: "getYouTubeVideoInsights", method: "GET", path: "/analytics/youtube/video-insights", retry: "safe-read" },
+  listAdBusinesses: { operationId: "listAdBusinesses", method: "GET", path: "/ads/businesses", retry: "safe-read" },
+  listAdAccounts: { operationId: "listAdAccounts", method: "GET", path: "/ads/accounts", retry: "safe-read" },
+  createAdAccount: { operationId: "createAdAccount", method: "POST", path: "/ads/accounts", retry: "never" },
+  getAdAccount: { operationId: "getAdAccount", method: "GET", path: "/ads/accounts/{adAccountId}", retry: "safe-read" },
+  updateAdAccount: { operationId: "updateAdAccount", method: "PATCH", path: "/ads/accounts/{adAccountId}", retry: "never" },
+  getAdTree: { operationId: "getAdTree", method: "GET", path: "/ads/tree", retry: "safe-read" },
+  getAdInsights: { operationId: "getAdInsights", method: "GET", path: "/ads/insights", retry: "safe-read" },
+  listAdLeads: { operationId: "listAdLeads", method: "GET", path: "/ads/leads", retry: "safe-read" },
+  createCampaign: { operationId: "createCampaign", method: "POST", path: "/ads/campaigns", retry: "never" },
+  deleteCampaign: { operationId: "deleteCampaign", method: "DELETE", path: "/ads/campaigns/{campaignId}", retry: "never" },
+  setAdStatus: { operationId: "setAdStatus", method: "PUT", path: "/ads/status", retry: "never" },
+  updateAdGroup: { operationId: "updateAdGroup", method: "PATCH", path: "/ads/ad-groups/{adGroupId}", retry: "never" },
+  listAdTargeting: { operationId: "listAdTargeting", method: "GET", path: "/ads/targeting", retry: "safe-read" },
+  listAdIdentities: { operationId: "listAdIdentities", method: "GET", path: "/ads/identities", retry: "safe-read" },
+  createAdIdentity: { operationId: "createAdIdentity", method: "POST", path: "/ads/identities", retry: "never" },
+  getXUsage: { operationId: "getXUsage", method: "GET", path: "/usage/x", retry: "safe-read" },
+  listWebhooks: { operationId: "listWebhooks", method: "GET", path: "/webhooks", retry: "safe-read" },
+  createWebhook: { operationId: "createWebhook", method: "POST", path: "/webhooks", retry: "never" },
+  deleteWebhook: { operationId: "deleteWebhook", method: "DELETE", path: "/webhooks/{webhookId}", retry: "never" }
+};
+
+// src/resources/accounts.ts
+var AccountsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listAccounts(args = {}, options = {}) {
+    return this.transport.request({ operation: operations.listAccounts, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  listProfileAccounts(args, options = {}) {
+    return this.transport.request({ operation: operations.listProfileAccounts, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getAccount(args, options = {}) {
+    return this.transport.request({ operation: operations.getAccount, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  updateAccount(args, options = {}) {
+    return this.transport.request({ operation: operations.updateAccount, path: args.path, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  disconnectAccount(args, options = {}) {
+    return this.transport.request({ operation: operations.disconnectAccount, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  refreshAccounts(args, options = {}) {
+    return this.transport.request({ operation: operations.refreshAccounts, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/resources/profiles.ts
+var ProfilesResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listProfiles(_args = {}, options = {}) {
+    return this.transport.request({ operation: operations.listProfiles, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  createProfile(args, options = {}) {
+    return this.transport.request({ operation: operations.createProfile, body: args.body, idempotencyKey: options.idempotencyKey, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getProfile(args, options = {}) {
+    return this.transport.request({ operation: operations.getProfile, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  updateProfile(args, options = {}) {
+    return this.transport.request({ operation: operations.updateProfile, path: args.path, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  deleteProfile(args, options = {}) {
+    return this.transport.request({ operation: operations.deleteProfile, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  startConnection(args, options = {}) {
+    return this.transport.request({ operation: operations.startConnection, path: args.path, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getConnection(args, options = {}) {
+    return this.transport.request({ operation: operations.getConnection, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+async function blobFromPath(path, options = {}) {
+  return fs.openAsBlob(path, options.contentType === void 0 ? void 0 : { type: options.contentType });
+}
+async function putDirectUploads(transport, descriptors, files, options = {}) {
+  if (descriptors.length !== files.length) throw new TypeError("The media upload manifest was incomplete");
+  const byId = new Map(descriptors.map((descriptor2) => [descriptor2.clientId, descriptor2]));
+  const concurrency = options.concurrency ?? 3;
+  if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 10) throw new TypeError("concurrency must be an integer between 1 and 10");
+  const total = files.reduce((sum, file) => sum + file.size, 0);
+  let completedBytes = 0;
+  let completedFiles = 0;
+  const result = new Array(files.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < files.length) {
+      const index = next++;
+      const descriptor2 = byId.get(String(index));
+      const file = files[index];
+      if (!descriptor2 || !file) throw new TypeError("The media upload manifest was incomplete");
+      await transport.upload(descriptor2.url, descriptor2.method, descriptor2.headers, file, options);
+      completedBytes += file.size;
+      completedFiles += 1;
+      options.onProgress?.({ loaded: completedBytes, total, completedFiles, totalFiles: files.length });
+      result[index] = descriptor2.uploadId;
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, files.length) }, () => worker()));
+  return result;
+}
+async function fileFromPath(path$1, options = {}) {
+  const blob = await blobFromPath(path$1, options);
+  return new File([blob], options.name ?? path.basename(path$1), options.contentType === void 0 ? void 0 : { type: options.contentType });
+}
+
+// src/resources/posts.ts
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function collectFiles(value, key, collected) {
+  if (isBlob(value)) {
+    const reference = { upload_id: "" };
+    collected.push({ file: value, reference, purpose: key === "thumbnail" ? "youtube_thumbnail" : "post_media" });
+    return reference;
+  }
+  if (Array.isArray(value)) return value.map((item) => collectFiles(item, key, collected));
+  if (value !== null && typeof value === "object") {
+    const record2 = value;
+    if (isBlob(record2.file)) {
+      const reference = { upload_id: "" };
+      collected.push({ file: record2.file, reference, purpose: key === "thumbnail" ? "youtube_thumbnail" : "post_media" });
+      const metadata = Object.fromEntries(Object.entries(record2).filter(([name]) => name !== "file"));
+      return Object.assign(reference, metadata);
+    }
+    return Object.fromEntries(Object.entries(record2).map(([name, item]) => [name, collectFiles(item, name, collected)]));
+  }
+  return value;
+}
+var PostsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listPosts(args = {}, options = {}) {
+    return this.transport.request({ operation: operations.listPosts, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  createMediaUploads(args, options = {}) {
+    return this.transport.request({ operation: operations.createMediaUploads, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  async profileIdFor(accountId, explicit, options) {
+    if (explicit) return explicit;
+    const response = await this.transport.request({ operation: operations.listAccounts, query: { accountId }, signal: options.signal, timeoutMs: options.timeoutMs });
+    const account = response.data.accounts?.[0];
+    if (!account?.profileId) throw new TypeError("A profileId is required to upload media for this account");
+    return account.profileId;
+  }
+  async stageBody(body, options) {
+    const files = [];
+    const stagedBody = collectFiles(body, void 0, files);
+    if (!files.length) return stagedBody;
+    const platform = body.platform;
+    if (!["instagram", "facebook", "tiktok", "youtube", "x", "bluesky"].includes(platform)) throw new TypeError("A supported platform is required for media upload");
+    const accountId = body.accountId;
+    if (typeof accountId !== "string") throw new TypeError("accountId is required for media upload");
+    const profileId = await this.profileIdFor(accountId, typeof body.profileId === "string" ? body.profileId : void 0, options);
+    const declaration = files.map(({ file, purpose }, index) => {
+      if (!file.type) throw new TypeError("Every uploaded Blob needs a content type");
+      return { clientId: String(index), purpose, contentType: file.type, size: file.size, ..."name" in file && typeof file.name === "string" ? { filename: file.name } : {} };
+    });
+    const initiated = await this.createMediaUploads({ body: { profileId, platform, files: declaration } }, options);
+    const uploadIds = await putDirectUploads(this.transport, initiated.data.uploads, files.map(({ file }) => file), options);
+    uploadIds.forEach((uploadId, index) => {
+      files[index].reference.upload_id = uploadId;
+    });
+    return stagedBody;
+  }
+  async createPost(args, options = {}) {
+    const body = await this.stageBody(args.body, options);
+    return this.transport.request({ operation: operations.createPost, body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  async uploadYouTubeVideo(args, options = {}) {
+    const body = await this.stageBody({ ...args.body, platform: "youtube" }, options);
+    return this.transport.request({ operation: operations.uploadYouTubeVideo, body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  deleteXPost(args, options = {}) {
+    return this.transport.request({ operation: operations.deleteXPost, path: args.path, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  deleteBlueskyPost(args, options = {}) {
+    return this.transport.request({ operation: operations.deleteBlueskyPost, path: args.path, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getInstagramPostStatus(args, options = {}) {
+    return this.transport.request({ operation: operations.getInstagramPostStatus, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getFacebookPostStatus(args, options = {}) {
+    return this.transport.request({ operation: operations.getFacebookPostStatus, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getTikTokPostStatus(args, options = {}) {
+    return this.transport.request({ operation: operations.getTikTokPostStatus, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getTikTokCreatorInfo(args, options = {}) {
+    return this.transport.request({ operation: operations.getTikTokCreatorInfo, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getYouTubeVideoStatus(args, options = {}) {
+    return this.transport.request({ operation: operations.getYouTubeVideoStatus, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/resources/comments.ts
+var CommentsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listComments(args, options = {}) {
+    return this.transport.request({ operation: operations.listComments, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  createComment(args, options = {}) {
+    return this.transport.request({ operation: operations.createComment, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  updateComment(args, options = {}) {
+    return this.transport.request({ operation: operations.updateComment, path: args.path, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  deleteComment(args, options = {}) {
+    return this.transport.request({ operation: operations.deleteComment, path: args.path, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/resources/messages.ts
+var MessagesResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listMessages(args = {}, options = {}) {
+    return this.transport.request({ operation: operations.listMessages, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  sendMessage(args, options = {}) {
+    return this.transport.request({ operation: operations.sendMessage, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  sendInstagramMessage(args, options = {}) {
+    return this.transport.request({ operation: operations.sendInstagramMessage, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/resources/analytics.ts
+var AnalyticsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  getInstagramAccountInsights(args, options = {}) {
+    return this.transport.request({ operation: operations.getInstagramAccountInsights, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getFacebookPageMetrics(args, options = {}) {
+    return this.transport.request({ operation: operations.getFacebookPageMetrics, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getTikTokAccountAnalytics(args, options = {}) {
+    return this.transport.request({ operation: operations.getTikTokAccountAnalytics, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getTikTokAccountInsights(args, options = {}) {
+    return this.transport.request({ operation: operations.getTikTokAccountInsights, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getTikTokVideoInsights(args, options = {}) {
+    return this.transport.request({ operation: operations.getTikTokVideoInsights, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getYouTubeChannelInsights(args, options = {}) {
+    return this.transport.request({ operation: operations.getYouTubeChannelInsights, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getYouTubeVideoInsights(args, options = {}) {
+    return this.transport.request({ operation: operations.getYouTubeVideoInsights, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/resources/ads.ts
+function requiredIdempotency(options) {
+  const key = options?.idempotencyKey;
+  if (typeof key !== "string" || key.trim() === "" || /[\u0000-\u001f\u007f\r\n]/.test(key)) throw new TypeError("idempotencyKey must be a nonblank valid HTTP header value");
+  return key;
+}
+var AdsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listAdBusinesses(args = {}, options = {}) {
+    return this.transport.request({ operation: operations.listAdBusinesses, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  listAdAccounts(args = {}, options = {}) {
+    return this.transport.request({ operation: operations.listAdAccounts, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  createAdAccount(args, options) {
+    const idempotencyKey = requiredIdempotency(options);
+    return this.transport.request({ operation: operations.createAdAccount, query: args.query, body: args.body, idempotencyKey, signal: options?.signal, timeoutMs: options?.timeoutMs });
+  }
+  getAdAccount(args, options = {}) {
+    return this.transport.request({ operation: operations.getAdAccount, path: args.path, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  updateAdAccount(args, options = {}) {
+    return this.transport.request({ operation: operations.updateAdAccount, path: args.path, query: args.query, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getAdTree(args, options = {}) {
+    return this.transport.request({ operation: operations.getAdTree, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  getAdInsights(args, options = {}) {
+    return this.transport.request({ operation: operations.getAdInsights, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  listAdLeads(args = {}, options = {}) {
+    return this.transport.request({ operation: operations.listAdLeads, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  createCampaign(args, options) {
+    const idempotencyKey = requiredIdempotency(options);
+    return this.transport.request({ operation: operations.createCampaign, query: args.query, body: args.body, idempotencyKey, signal: options?.signal, timeoutMs: options?.timeoutMs });
+  }
+  deleteCampaign(args, options = {}) {
+    return this.transport.request({ operation: operations.deleteCampaign, path: args.path, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  setAdStatus(args, options = {}) {
+    return this.transport.request({ operation: operations.setAdStatus, query: args.query, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  updateAdGroup(args, options = {}) {
+    return this.transport.request({ operation: operations.updateAdGroup, path: args.path, query: args.query, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  listAdTargeting(args, options = {}) {
+    return this.transport.request({ operation: operations.listAdTargeting, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  listAdIdentities(args, options = {}) {
+    return this.transport.request({ operation: operations.listAdIdentities, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  createAdIdentity(args, options = {}) {
+    return this.transport.request({ operation: operations.createAdIdentity, query: args.query, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/resources/usage.ts
+var UsageResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  getXUsage(_args = {}, options = {}) {
+    return this.transport.request({ operation: operations.getXUsage, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  listWebhooks(args, options = {}) {
+    return this.transport.request({ operation: operations.listWebhooks, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  createWebhook(args, options = {}) {
+    return this.transport.request({ operation: operations.createWebhook, body: args.body, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+  deleteWebhook(args, options = {}) {
+    return this.transport.request({ operation: operations.deleteWebhook, path: args.path, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+// src/client.ts
+var Adeli = class {
+  profiles;
+  accounts;
+  posts;
+  comments;
+  messages;
+  analytics;
+  ads;
+  usage;
+  webhooks;
+  transport;
+  constructor(options = {}) {
+    this.transport = new Transport(resolveConfig(options));
+    this.profiles = new ProfilesResource(this.transport);
+    this.accounts = new AccountsResource(this.transport);
+    this.posts = new PostsResource(this.transport);
+    this.comments = new CommentsResource(this.transport);
+    this.messages = new MessagesResource(this.transport);
+    this.analytics = new AnalyticsResource(this.transport);
+    this.ads = new AdsResource(this.transport);
+    this.usage = new UsageResource(this.transport);
+    this.webhooks = new WebhooksResource(this.transport);
+  }
+  /** Do not serialize client internals or its API key. */
+  toJSON() {
+    return {};
+  }
+  getMe(args = {}, options = {}) {
+    return this.transport.request({ operation: operations.getMe, query: args.query, signal: options.signal, timeoutMs: options.timeoutMs });
+  }
+};
+
+exports.Adeli = Adeli;
+exports.AdeliApiError = AdeliApiError;
+exports.AdeliError = AdeliError;
+exports.AuthenticationError = AuthenticationError;
+exports.CancellationError = CancellationError;
+exports.ConfigurationError = ConfigurationError;
+exports.MalformedResponseError = MalformedResponseError;
+exports.NetworkError = NetworkError;
+exports.PermissionRequiredError = PermissionRequiredError;
+exports.RateLimitError = RateLimitError;
+exports.RedirectError = RedirectError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+exports.blobFromPath = blobFromPath;
+exports.fileFromPath = fileFromPath;
+exports.isAdeliApiError = isAdeliApiError;
+exports.isPermissionRequiredDetails = isPermissionRequiredDetails;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map