@publishq/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,1947 @@
+// src/generated/core/bodySerializer.gen.ts
+var serializeFormDataPair = (data, key, value) => {
+  if (typeof value === "string" || value instanceof Blob) {
+    data.append(key, value);
+  } else if (value instanceof Date) {
+    data.append(key, value.toISOString());
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+var formDataBodySerializer = {
+  bodySerializer: (body) => {
+    const data = new FormData();
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === void 0 || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeFormDataPair(data, key, v));
+      } else {
+        serializeFormDataPair(data, key, value);
+      }
+    });
+    return data;
+  }
+};
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+};
+
+// src/generated/core/params.gen.ts
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+
+// src/generated/core/serverSentEvents.gen.ts
+function createSseClient({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url: url2,
+  ...options
+}) {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url2, requestInit);
+        if (onRequest) {
+          request = await onRequest(url2, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n?/g, "\n");
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+}
+
+// src/generated/core/pathSerializer.gen.ts
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(
+    ([key, v]) => serializePrimitiveParam({
+      allowReserved,
+      name: style === "deepObject" ? `${name}[${key}]` : key,
+      value: v
+    })
+  ).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// src/generated/core/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path, url: _url }) => {
+  let url2 = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url2 = url2.replace(match, serializeArrayParam({ explode, name, style, value }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url2 = url2.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value,
+            valueOnly: true
+          })
+        );
+        continue;
+      }
+      if (style === "matrix") {
+        url2 = url2.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value
+          })}`
+        );
+        continue;
+      }
+      const replaceValue = encodeURIComponent(
+        style === "label" ? `.${value}` : value
+      );
+      url2 = url2.replace(match, replaceValue);
+    }
+  }
+  return url2;
+};
+var getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url2 = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url2 = defaultPathSerializer({ path, url: url2 });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url2 += `?${search}`;
+  }
+  return url2;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+
+// src/generated/core/auth.gen.ts
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// src/generated/client/utils.gen.ts
+var createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+async function setAuthParams(options) {
+  for (const auth of options.security ?? []) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+}
+var buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
+var mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : value
+        );
+      }
+    }
+  }
+  return mergedHeaders;
+};
+var Interceptors = class {
+  fns = [];
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+};
+var createInterceptors = () => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+
+// src/generated/client/client.gen.ts
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams(opts);
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const resolvedOpts = opts;
+    const url2 = buildUrl(resolvedOpts);
+    return { opts: resolvedOpts, url: url2 };
+  };
+  const request = async (options) => {
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+    const responseStyle = options.responseStyle ?? _config.responseStyle;
+    let request2;
+    let response;
+    try {
+      const { opts, url: url2 } = await beforeRequest(options);
+      const requestInit = {
+        redirect: "follow",
+        ...opts,
+        body: getValidRequestBody(opts)
+      };
+      request2 = new Request(url2, requestInit);
+      for (const fn of interceptors.request.fns) {
+        if (fn) {
+          request2 = await fn(request2, opts);
+        }
+      }
+      const _fetch = opts.fetch;
+      response = await _fetch(request2);
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          response = await fn(response, request2, opts);
+        }
+      }
+      const result = {
+        request: request2,
+        response
+      };
+      if (response.ok) {
+        const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+        if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+          let emptyData;
+          switch (parseAs) {
+            case "arrayBuffer":
+            case "blob":
+            case "text":
+              emptyData = await response[parseAs]();
+              break;
+            case "formData":
+              emptyData = new FormData();
+              break;
+            case "stream":
+              emptyData = response.body;
+              break;
+            case "json":
+            default:
+              emptyData = {};
+              break;
+          }
+          return opts.responseStyle === "data" ? emptyData : {
+            data: emptyData,
+            ...result
+          };
+        }
+        let data;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "formData":
+          case "text":
+            data = await response[parseAs]();
+            break;
+          case "json": {
+            const text = await response.text();
+            data = text ? JSON.parse(text) : {};
+            break;
+          }
+          case "stream":
+            return opts.responseStyle === "data" ? response.body : {
+              data: response.body,
+              ...result
+            };
+        }
+        if (parseAs === "json") {
+          if (opts.responseValidator) {
+            await opts.responseValidator(data);
+          }
+          if (opts.responseTransformer) {
+            data = await opts.responseTransformer(data);
+          }
+        }
+        return opts.responseStyle === "data" ? data : {
+          data,
+          ...result
+        };
+      }
+      const textError = await response.text();
+      let jsonError;
+      try {
+        jsonError = JSON.parse(textError);
+      } catch {
+      }
+      throw jsonError ?? textError;
+    } catch (error) {
+      let finalError = error;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = await fn(finalError, response, request2, options);
+        }
+      }
+      finalError = finalError || {};
+      if (throwOnError) {
+        throw finalError;
+      }
+      return responseStyle === "data" ? void 0 : {
+        error: finalError,
+        request: request2,
+        response
+      };
+    }
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url: url2 } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      method,
+      onRequest: async (url3, init) => {
+        let request2 = new Request(url3, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url: url2
+    });
+  };
+  const _buildUrl = (options) => buildUrl({ ..._config, ...options });
+  return {
+    buildUrl: _buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+
+// src/generated/client.gen.ts
+var client = createClient(createConfig({ baseUrl: "https://publishq.com/api/v1" }));
+
+// src/generated/sdk.gen.ts
+var Posts = class {
+  /**
+   * List posts
+   *
+   * Returns a paginated list of posts.
+   */
+  static listPosts(options) {
+    return (options?.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/posts",
+      ...options
+    });
+  }
+  /**
+   * Create posts
+   *
+   * Creates a post for one or more connected accounts.
+   */
+  static createPost(options) {
+    return (options.client ?? client).post({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/posts",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete post
+   *
+   * Deletes a scheduled or draft post by its ID. Returns no body on success.
+   */
+  static deletePost(options) {
+    return (options.client ?? client).delete({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/posts/{id}",
+      ...options
+    });
+  }
+  /**
+   * Get post
+   *
+   * Get one post by its PublishQ post ID. Returns the post details and the connected account metadata needed to identify where it belongs.
+   */
+  static getPost(options) {
+    return (options.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/posts/{id}",
+      ...options
+    });
+  }
+  /**
+   * Update post
+   *
+   * Update a draft or scheduled post. You can change the content, the scheduled date, or both. Published and publishing posts cannot be updated.
+   */
+  static updatePost(options) {
+    return (options.client ?? client).patch({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/posts/{id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Remove account from post
+   *
+   * Removes one account from an existing post so it will no longer be published there. Other accounts in the same post are not changed.
+   */
+  static removePostAccount(options) {
+    return (options.client ?? client).delete({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/posts/{id}/accounts/{accountId}",
+      ...options
+    });
+  }
+};
+var Accounts = class {
+  /**
+   * List accounts
+   *
+   * List connected social accounts for the authenticated API key owner. You can filter by workspace and by one or more platforms.
+   */
+  static listAccounts(options) {
+    return (options?.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/accounts",
+      ...options
+    });
+  }
+  /**
+   * Get TikTok creator info
+   *
+   * Returns the TikTok creator's current privacy options, interaction settings, and maximum video duration. Call this before posting to TikTok — the `privacyLevel` you set must match one of the returned `privacyLevelOptions`.
+   */
+  static getTikTokCreatorInfo(options) {
+    return (options.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/accounts/{id}/tiktok-creator-info",
+      ...options
+    });
+  }
+};
+var Workspaces = class {
+  /**
+   * List workspaces
+   *
+   * Return your workspaces, including their names, colors, and account counts.
+   */
+  static listWorkspaces(options) {
+    return (options?.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/workspaces",
+      ...options
+    });
+  }
+  /**
+   * Create workspace
+   *
+   * Create a workspace to organize your connected social accounts.
+   */
+  static createWorkspace(options) {
+    return (options.client ?? client).post({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/workspaces",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get workspace
+   *
+   * Return one workspace by ID, including its name, color, description, and account count.
+   */
+  static getWorkspace(options) {
+    return (options.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/workspaces/{id}",
+      ...options
+    });
+  }
+};
+var Media = class {
+  /**
+   * List media
+   *
+   * Return your uploaded and generated media files. You can filter by ID, type, and source before reusing them in posts.
+   */
+  static listMedia(options) {
+    return (options?.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/media",
+      ...options
+    });
+  }
+  /**
+   * Upload media
+   *
+   * Upload one media file with multipart form data. The returned media ID can then be attached to posts.
+   */
+  static uploadMedia(options) {
+    return (options.client ?? client).post({
+      ...formDataBodySerializer,
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/media",
+      ...options,
+      headers: {
+        "Content-Type": null,
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get media
+   *
+   * Return one media file by ID, including its URL, source, and usage count.
+   */
+  static getMedia(options) {
+    return (options.client ?? client).get({
+      security: [{ scheme: "bearer", type: "http" }],
+      url: "/media/{id}",
+      ...options
+    });
+  }
+};
+
+// src/generated/zod.gen.ts
+import * as z from "zod/mini";
+var zApiErrorCode = z.enum([
+  "missing_auth",
+  "invalid_auth_format",
+  "invalid_api_key",
+  "api_key_expired",
+  "insufficient_scope",
+  "validation_failed",
+  "route_not_found",
+  "internal_server_error",
+  "rate_limit_exceeded",
+  "post_not_found",
+  "post_forbidden",
+  "post_not_editable",
+  "media_not_found",
+  "media_in_use",
+  "storage_limit_exceeded",
+  "free_media_limit_exceeded",
+  "free_pending_media_limit_exceeded",
+  "file_required",
+  "file_too_large",
+  "unsupported_file_type",
+  "unsupported_media_type",
+  "invalid_file_extension",
+  "social_accounts_not_found",
+  "social_accounts_expired",
+  "platform_validation_failed",
+  "posting_limits_exceeded",
+  "scheduled_at_required",
+  "invalid_scheduled_at",
+  "scheduled_at_too_soon",
+  "reschedulable_posts_not_found",
+  "workspace_not_found",
+  "workspace_forbidden",
+  "workspace_owner_required",
+  "workspace_account_not_found",
+  "workspace_account_conflict",
+  "workspace_member_not_found",
+  "workspace_member_conflict",
+  "workspace_invitation_invalid",
+  "workspace_invitation_expired"
+]);
+var zApiError = z.object({
+  error: z.object({
+    title: z.string(),
+    status: z.int(),
+    code: zApiErrorCode,
+    message: z.string(),
+    instance: z.optional(z.string()),
+    details: z.optional(z.record(z.string(), z.record(z.string(), z.unknown())))
+  })
+});
+var zPagination = z.object({
+  page: z.int().register(z.globalRegistry, {
+    description: "Current page number (starting from 1)."
+  }),
+  limit: z.int().register(z.globalRegistry, {
+    description: "Maximum number of items returned per page."
+  }),
+  total: z.int().register(z.globalRegistry, {
+    description: "Total number of matching items."
+  }),
+  totalPages: z.int().register(z.globalRegistry, {
+    description: "Total number of pages for the current limit."
+  }),
+  hasNext: z.boolean().register(z.globalRegistry, {
+    description: "Whether another page exists after the current one."
+  }),
+  hasPrev: z.boolean().register(z.globalRegistry, {
+    description: "Whether another page exists before the current one."
+  })
+});
+var zBlueskyPlatformSpecificSettings = z.record(z.string(), z.never()).register(z.globalRegistry, {
+  description: "Bluesky-specific publishing settings. No settings are currently available."
+});
+var zInstagramPlatformSpecificSettings = z.object({
+  contentType: z.optional(z.enum(["story", "reels"]).register(z.globalRegistry, {
+    description: 'Set to "story" for ephemeral content that disappears after 24 hours. Set to "reels" to explicitly publish as a Reel. Omit for a regular feed post or carousel \u2014 single videos are automatically published as Reels.'
+  })),
+  shareToFeed: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Reels only. When true (default), the reel can appear in both the Feed and Reels tabs. When false, it only appears in the Reels tab. Neither value guarantees placement \u2014 Instagram's algorithm decides based on eligibility and relevance."
+  })),
+  trialParams: z.optional(z.object({
+    graduationStrategy: z.enum(["MANUAL", "SS_PERFORMANCE"]).register(z.globalRegistry, {
+      description: "MANUAL: the trial reel can be graduated (converted to a public reel) manually in the Instagram app. SS_PERFORMANCE: Instagram automatically graduates the reel if it performs well with non-followers."
+    })
+  }).register(z.globalRegistry, {
+    description: "Reels only. Publish as a trial reel \u2014 shown only to non-followers first. Instagram requires a public account with at least 200 followers and rejects the post otherwise."
+  })),
+  audioName: z.optional(z.string().register(z.globalRegistry, {
+    description: "Reels only. Custom name for the audio track of your reel. Can only be set once \u2014 either at creation time or later from the audio page in the Instagram app."
+  }))
+}).register(z.globalRegistry, {
+  description: "Instagram-specific post settings. All fields are optional \u2014 omit the entire object for a regular feed post or carousel."
+});
+var zFacebookPlatformSpecificSettings = z.object({
+  contentType: z.optional(z.enum(["story"]).register(z.globalRegistry, {
+    description: 'Set to "story" for ephemeral content that disappears after 24 hours. Omit for a regular post \u2014 single videos are automatically published as Reels (Facebook no longer has a separate video format).'
+  }))
+}).register(z.globalRegistry, {
+  description: "Facebook-specific post settings. All fields are optional \u2014 omit the entire object for a regular post."
+});
+var zInstagramTrialParams = z.object({
+  graduationStrategy: z.enum(["MANUAL", "SS_PERFORMANCE"]).register(z.globalRegistry, {
+    description: "MANUAL: the trial reel can be graduated (converted to a public reel) manually in the Instagram app. SS_PERFORMANCE: Instagram automatically graduates the reel if it performs well with non-followers."
+  })
+}).register(z.globalRegistry, {
+  description: "Trial reel graduation settings. Trial reels are shown only to non-followers first. If the reel performs well (SS_PERFORMANCE) or you manually approve it (MANUAL), it gets promoted to a regular reel visible to followers."
+});
+var zYouTubePlatformSpecificSettings = z.object({
+  description: z.optional(z.string().check(z.maxLength(5e3)).register(z.globalRegistry, {
+    description: "Video description. Max 5000 characters. Shown below the video title on the watch page."
+  })),
+  privacyStatus: z.optional(z.enum([
+    "public",
+    "unlisted",
+    "private"
+  ]).register(z.globalRegistry, {
+    description: "Video privacy status. Defaults to public. Unverified API projects are restricted to private."
+  })),
+  madeForKids: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Declare the video as made for kids (COPPA). When true, personalized ads are disabled and some features (comments, notifications) are turned off."
+  })),
+  containsSyntheticMedia: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Disclose that the video contains realistic altered or synthetic (AI-generated) content."
+  })),
+  categoryId: z.optional(z.enum([
+    "1",
+    "2",
+    "10",
+    "15",
+    "17",
+    "19",
+    "20",
+    "22",
+    "23",
+    "24",
+    "25",
+    "26",
+    "27",
+    "28",
+    "29"
+  ]).register(z.globalRegistry, {
+    description: 'YouTube video category. Defaults to "22" (People & Blogs). Valid IDs: 1 (Film & Animation), 2 (Autos & Vehicles), 10 (Music), 15 (Pets & Animals), 17 (Sports), 19 (Travel & Events), 20 (Gaming), 22 (People & Blogs), 23 (Comedy), 24 (Entertainment), 25 (News & Politics), 26 (Howto & Style), 27 (Education), 28 (Science & Technology), 29 (Nonprofits & Activism).'
+  })),
+  tags: z.optional(z.array(z.string()).register(z.globalRegistry, {
+    description: "Keyword tags for the video. Duplicates are removed. Total of all tags must be under 500 characters. Tags with spaces count as quoted (2 extra chars). Commas between tags also count."
+  })),
+  embeddable: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Whether the video can be embedded on other websites. Defaults to true."
+  })),
+  playlistId: z.optional(z.string().register(z.globalRegistry, {
+    description: "Playlist ID to add the video to after upload."
+  }))
+}).register(z.globalRegistry, {
+  description: "YouTube-specific upload settings, such as description and privacy."
+});
+var zTikTokPlatformSpecificSettings = z.object({
+  privacyLevel: z.enum([
+    "PUBLIC_TO_EVERYONE",
+    "FOLLOWER_OF_CREATOR",
+    "MUTUAL_FOLLOW_FRIENDS",
+    "SELF_ONLY"
+  ]).register(z.globalRegistry, {
+    description: "Who can view this post. The value must match one of the options returned by the TikTok creator_info/query endpoint for the target account."
+  }),
+  disableComment: z.boolean().register(z.globalRegistry, {
+    description: 'If true, other TikTok users cannot comment on this post. Ignored if the creator has set comments to "No one" in their privacy settings.'
+  }),
+  disableDuet: z.boolean().register(z.globalRegistry, {
+    description: "If true, other TikTok users cannot create Duets with this post. Only applies to video posts. Ignored for photo posts and private accounts."
+  }),
+  disableStitch: z.boolean().register(z.globalRegistry, {
+    description: "If true, other TikTok users cannot create Stitches with this post. Only applies to video posts. Ignored for photo posts and private accounts."
+  }),
+  brandContentToggle: z.boolean().register(z.globalRegistry, {
+    description: "Set to true if this is a paid partnership promoting a third-party business. Required by TikTok for branded content disclosure."
+  }),
+  brandOrganicToggle: z.boolean().register(z.globalRegistry, {
+    description: "Set to true if this post promotes the creator's own business."
+  }),
+  autoAddMusic: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Photo posts only. If true, TikTok automatically adds recommended background music to the photo carousel. Users can change the music later in the TikTok app."
+  })),
+  videoMadeWithAi: z.optional(z.boolean().register(z.globalRegistry, {
+    description: 'Video posts only. Set to true if the video is AI-generated content. The video will be labeled with a "Creator labeled as AI-generated" tag.'
+  })),
+  description: z.optional(z.string().check(z.maxLength(4e3)).register(z.globalRegistry, {
+    description: "Photo posts only. Additional description text (max 4000 characters). Hashtags and mentions in the description are parsed by TikTok."
+  })),
+  photoCoverIndex: z.optional(z.int().check(z.gte(0)).register(z.globalRegistry, {
+    description: "Photo posts only. Zero-based index of the image to use as the carousel cover. Defaults to 0 (first image)."
+  }))
+}).register(z.globalRegistry, {
+  description: "TikTok-specific publishing settings. Privacy level and brand toggles are required for all posts. Duet/stitch settings only apply to video posts. autoAddMusic only applies to photo posts."
+});
+var zLinkedInPlatformSpecificSettings = z.object({
+  visibility: z.optional(z.enum(["CONNECTIONS", "PUBLIC"]).register(z.globalRegistry, {
+    description: "Who can see the post. PUBLIC (anyone on LinkedIn) or CONNECTIONS (only your connections). Defaults to PUBLIC. Only available for personal profiles \u2014 company pages are always public."
+  }))
+}).register(z.globalRegistry, {
+  description: "LinkedIn-specific publishing settings, such as post visibility."
+});
+var zThreadsPlatformSpecificSettings = z.object({
+  topicTag: z.optional(z.string().check(z.minLength(1), z.maxLength(50)).register(z.globalRegistry, {
+    description: "A topic tag for the post (without the # prefix). Max 50 characters. Periods (.) and ampersands (&) are not allowed. Overrides any auto-detected topic from inline hashtags."
+  }))
+}).register(z.globalRegistry, {
+  description: "Threads-specific publishing settings."
+});
+var zTwitterPlatformSpecificSettings = z.object({
+  communityId: z.optional(z.string().check(z.regex(/^[0-9]{1,19}$/)).register(z.globalRegistry, {
+    description: "Post to a specific X Community. The authenticated user must be a member of the community."
+  })),
+  shareWithFollowers: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "When posting to a community, also share the post with your followers. Only applies when `communityId` is set."
+  })),
+  forSuperFollowersOnly: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Make this post exclusive to your subscribers (super followers)."
+  })),
+  replySettings: z.optional(z.enum([
+    "following",
+    "mentionedUsers",
+    "subscribers",
+    "verified"
+  ]).register(z.globalRegistry, {
+    description: "Control who can reply. `following`: only people you follow. `mentionedUsers`: only people mentioned in the post. `subscribers`: only your subscribers. `verified`: only verified users."
+  })),
+  quoteTweetId: z.optional(z.string().check(z.regex(/^[0-9]{1,19}$/)).register(z.globalRegistry, {
+    description: "ID of an existing tweet to quote. Mutually exclusive with poll and media."
+  })),
+  replyToTweetId: z.optional(z.string().check(z.regex(/^[0-9]{1,19}$/)).register(z.globalRegistry, {
+    description: "ID of an existing tweet to reply to. Your post will appear as a reply in that tweet's thread."
+  })),
+  poll: z.optional(z.object({
+    options: z.array(z.string().check(z.minLength(1), z.maxLength(25))).check(z.minLength(2), z.maxLength(4)).register(z.globalRegistry, {
+      description: "Poll choices. 2-4 options, max 25 characters each."
+    }),
+    durationMinutes: z.int().check(z.gte(5), z.lte(10080)).register(z.globalRegistry, {
+      description: "How long the poll stays open, in minutes. Min 5 minutes, max 7 days (10080)."
+    })
+  }).register(z.globalRegistry, {
+    description: "Create a poll. Mutually exclusive with media and `quoteTweetId`."
+  }))
+}).register(z.globalRegistry, {
+  description: "X (Twitter) specific post settings. All fields are optional."
+});
+var zSocialPlatform = z.enum([
+  "TWITTER",
+  "INSTAGRAM",
+  "FACEBOOK",
+  "LINKEDIN",
+  "YOUTUBE",
+  "TIKTOK",
+  "THREADS",
+  "BLUESKY"
+]);
+var zPostStatus = z.enum([
+  "DRAFT",
+  "SCHEDULED",
+  "PUBLISHING",
+  "PUBLISHED",
+  "FAILED"
+]);
+var zPostOverrides = z.object({
+  content: z.optional(z.string().register(z.globalRegistry, {
+    description: "Custom text for this account, overriding the post-level content."
+  })),
+  thumbnailTimestamp: z.optional(z.int().check(z.gte(0)).register(z.globalRegistry, {
+    description: "Video thumbnail timestamp in milliseconds. Applies to Instagram and TikTok."
+  })),
+  mediaIds: z.optional(z.array(z.uuid()).register(z.globalRegistry, {
+    description: "Replacement media for this account. Completely replaces the post-level media."
+  }))
+});
+var zPlatformSpecificSettings = z.union([
+  z.object({
+    description: z.optional(z.string().check(z.maxLength(5e3)).register(z.globalRegistry, {
+      description: "Video description. Max 5000 characters. Shown below the video title on the watch page."
+    })),
+    privacyStatus: z.optional(z.enum([
+      "public",
+      "unlisted",
+      "private"
+    ]).register(z.globalRegistry, {
+      description: "Video privacy status. Defaults to public. Unverified API projects are restricted to private."
+    })),
+    madeForKids: z.optional(z.boolean().register(z.globalRegistry, {
+      description: "Declare the video as made for kids (COPPA). When true, personalized ads are disabled and some features (comments, notifications) are turned off."
+    })),
+    containsSyntheticMedia: z.optional(z.boolean().register(z.globalRegistry, {
+      description: "Disclose that the video contains realistic altered or synthetic (AI-generated) content."
+    })),
+    categoryId: z.optional(z.enum([
+      "1",
+      "2",
+      "10",
+      "15",
+      "17",
+      "19",
+      "20",
+      "22",
+      "23",
+      "24",
+      "25",
+      "26",
+      "27",
+      "28",
+      "29"
+    ]).register(z.globalRegistry, {
+      description: 'YouTube video category. Defaults to "22" (People & Blogs). Valid IDs: 1 (Film & Animation), 2 (Autos & Vehicles), 10 (Music), 15 (Pets & Animals), 17 (Sports), 19 (Travel & Events), 20 (Gaming), 22 (People & Blogs), 23 (Comedy), 24 (Entertainment), 25 (News & Politics), 26 (Howto & Style), 27 (Education), 28 (Science & Technology), 29 (Nonprofits & Activism).'
+    })),
+    tags: z.optional(z.array(z.string()).register(z.globalRegistry, {
+      description: "Keyword tags for the video. Duplicates are removed. Total of all tags must be under 500 characters. Tags with spaces count as quoted (2 extra chars). Commas between tags also count."
+    })),
+    embeddable: z.optional(z.boolean().register(z.globalRegistry, {
+      description: "Whether the video can be embedded on other websites. Defaults to true."
+    })),
+    playlistId: z.optional(z.string().register(z.globalRegistry, {
+      description: "Playlist ID to add the video to after upload."
+    }))
+  }).register(z.globalRegistry, {
+    description: "YouTube-specific upload settings, such as description and privacy."
+  }),
+  z.object({
+    privacyLevel: z.enum([
+      "PUBLIC_TO_EVERYONE",
+      "FOLLOWER_OF_CREATOR",
+      "MUTUAL_FOLLOW_FRIENDS",
+      "SELF_ONLY"
+    ]).register(z.globalRegistry, {
+      description: "Who can view this post. The value must match one of the options returned by the TikTok creator_info/query endpoint for the target account."
+    }),
+    disableComment: z.boolean().register(z.globalRegistry, {
+      description: 'If true, other TikTok users cannot comment on this post. Ignored if the creator has set comments to "No one" in their privacy settings.'
+    }),
+    disableDuet: z.boolean().register(z.globalRegistry, {
+      description: "If true, other TikTok users cannot create Duets with this post. Only applies to video posts. Ignored for photo posts and private accounts."
+    }),
+    disableStitch: z.boolean().register(z.globalRegistry, {
+      description: "If true, other TikTok users cannot create Stitches with this post. Only applies to video posts. Ignored for photo posts and private accounts."
+    }),
+    brandContentToggle: z.boolean().register(z.globalRegistry, {
+      description: "Set to true if this is a paid partnership promoting a third-party business. Required by TikTok for branded content disclosure."
+    }),
+    brandOrganicToggle: z.boolean().register(z.globalRegistry, {
+      description: "Set to true if this post promotes the creator's own business."
+    }),
+    autoAddMusic: z.optional(z.boolean().register(z.globalRegistry, {
+      description: "Photo posts only. If true, TikTok automatically adds recommended background music to the photo carousel. Users can change the music later in the TikTok app."
+    })),
+    videoMadeWithAi: z.optional(z.boolean().register(z.globalRegistry, {
+      description: 'Video posts only. Set to true if the video is AI-generated content. The video will be labeled with a "Creator labeled as AI-generated" tag.'
+    })),
+    description: z.optional(z.string().check(z.maxLength(4e3)).register(z.globalRegistry, {
+      description: "Photo posts only. Additional description text (max 4000 characters). Hashtags and mentions in the description are parsed by TikTok."
+    })),
+    photoCoverIndex: z.optional(z.int().check(z.gte(0)).register(z.globalRegistry, {
+      description: "Photo posts only. Zero-based index of the image to use as the carousel cover. Defaults to 0 (first image)."
+    }))
+  }).register(z.globalRegistry, {
+    description: "TikTok-specific publishing settings. Privacy level and brand toggles are required for all posts. Duet/stitch settings only apply to video posts. autoAddMusic only applies to photo posts."
+  }),
+  z.object({
+    contentType: z.optional(z.enum(["story", "reels"]).register(z.globalRegistry, {
+      description: 'Set to "story" for ephemeral content that disappears after 24 hours. Set to "reels" to explicitly publish as a Reel. Omit for a regular feed post or carousel \u2014 single videos are automatically published as Reels.'
+    })),
+    shareToFeed: z.optional(z.boolean().register(z.globalRegistry, {
+      description: "Reels only. When true (default), the reel can appear in both the Feed and Reels tabs. When false, it only appears in the Reels tab. Neither value guarantees placement \u2014 Instagram's algorithm decides based on eligibility and relevance."
+    })),
+    trialParams: z.optional(z.object({
+      graduationStrategy: z.enum(["MANUAL", "SS_PERFORMANCE"]).register(z.globalRegistry, {
+        description: "MANUAL: the trial reel can be graduated (converted to a public reel) manually in the Instagram app. SS_PERFORMANCE: Instagram automatically graduates the reel if it performs well with non-followers."
+      })
+    }).register(z.globalRegistry, {
+      description: "Reels only. Publish as a trial reel \u2014 shown only to non-followers first. Instagram requires a public account with at least 200 followers and rejects the post otherwise."
+    })),
+    audioName: z.optional(z.string().register(z.globalRegistry, {
+      description: "Reels only. Custom name for the audio track of your reel. Can only be set once \u2014 either at creation time or later from the audio page in the Instagram app."
+    }))
+  }).register(z.globalRegistry, {
+    description: "Instagram-specific post settings. All fields are optional \u2014 omit the entire object for a regular feed post or carousel."
+  }),
+  z.object({
+    contentType: z.optional(z.enum(["story"]).register(z.globalRegistry, {
+      description: 'Set to "story" for ephemeral content that disappears after 24 hours. Omit for a regular post \u2014 single videos are automatically published as Reels (Facebook no longer has a separate video format).'
+    }))
+  }).register(z.globalRegistry, {
+    description: "Facebook-specific post settings. All fields are optional \u2014 omit the entire object for a regular post."
+  }),
+  z.object({
+    topicTag: z.optional(z.string().check(z.minLength(1), z.maxLength(50)).register(z.globalRegistry, {
+      description: "A topic tag for the post (without the # prefix). Max 50 characters. Periods (.) and ampersands (&) are not allowed. Overrides any auto-detected topic from inline hashtags."
+    }))
+  }).register(z.globalRegistry, {
+    description: "Threads-specific publishing settings."
+  }),
+  z.object({
+    communityId: z.optional(z.string().check(z.regex(/^[0-9]{1,19}$/)).register(z.globalRegistry, {
+      description: "Post to a specific X Community. The authenticated user must be a member of the community."
+    })),
+    shareWithFollowers: z.optional(z.boolean().register(z.globalRegistry, {
+      description: "When posting to a community, also share the post with your followers. Only applies when `communityId` is set."
+    })),
+    forSuperFollowersOnly: z.optional(z.boolean().register(z.globalRegistry, {
+      description: "Make this post exclusive to your subscribers (super followers)."
+    })),
+    replySettings: z.optional(z.enum([
+      "following",
+      "mentionedUsers",
+      "subscribers",
+      "verified"
+    ]).register(z.globalRegistry, {
+      description: "Control who can reply. `following`: only people you follow. `mentionedUsers`: only people mentioned in the post. `subscribers`: only your subscribers. `verified`: only verified users."
+    })),
+    quoteTweetId: z.optional(z.string().check(z.regex(/^[0-9]{1,19}$/)).register(z.globalRegistry, {
+      description: "ID of an existing tweet to quote. Mutually exclusive with poll and media."
+    })),
+    replyToTweetId: z.optional(z.string().check(z.regex(/^[0-9]{1,19}$/)).register(z.globalRegistry, {
+      description: "ID of an existing tweet to reply to. Your post will appear as a reply in that tweet's thread."
+    })),
+    poll: z.optional(z.object({
+      options: z.array(z.string().check(z.minLength(1), z.maxLength(25))).check(z.minLength(2), z.maxLength(4)).register(z.globalRegistry, {
+        description: "Poll choices. 2-4 options, max 25 characters each."
+      }),
+      durationMinutes: z.int().check(z.gte(5), z.lte(10080)).register(z.globalRegistry, {
+        description: "How long the poll stays open, in minutes. Min 5 minutes, max 7 days (10080)."
+      })
+    }).register(z.globalRegistry, {
+      description: "Create a poll. Mutually exclusive with media and `quoteTweetId`."
+    }))
+  }).register(z.globalRegistry, {
+    description: "X (Twitter) specific post settings. All fields are optional."
+  }),
+  z.object({
+    visibility: z.optional(z.enum(["CONNECTIONS", "PUBLIC"]).register(z.globalRegistry, {
+      description: "Who can see the post. PUBLIC (anyone on LinkedIn) or CONNECTIONS (only your connections). Defaults to PUBLIC. Only available for personal profiles \u2014 company pages are always public."
+    }))
+  }).register(z.globalRegistry, {
+    description: "LinkedIn-specific publishing settings, such as post visibility."
+  }),
+  z.record(z.string(), z.never()).register(z.globalRegistry, {
+    description: "Bluesky-specific publishing settings. No settings are currently available."
+  }),
+  z.record(z.string(), z.unknown())
+]);
+var zPostAccount = z.object({
+  accountId: z.uuid().register(z.globalRegistry, {
+    description: "The connected social account identifier."
+  }),
+  platform: zSocialPlatform,
+  accountName: z.string().register(z.globalRegistry, {
+    description: "Display name or username of the connected account."
+  }),
+  status: zPostStatus,
+  externalUrl: z.optional(z.url().register(z.globalRegistry, {
+    description: "Link to the published post on the social platform. Present only after successful publishing."
+  })),
+  publishedAt: z.optional(z.iso.datetime().register(z.globalRegistry, {
+    description: "When this account's post was published."
+  })),
+  errorMessage: z.optional(z.string().register(z.globalRegistry, {
+    description: "Error message from the platform if publishing failed for this account."
+  })),
+  postOverrides: z.optional(zPostOverrides),
+  platformSpecificSettings: z.optional(zPlatformSpecificSettings)
+});
+var zPost = z.object({
+  id: z.uuid().register(z.globalRegistry, {
+    description: "Unique post identifier."
+  }),
+  content: z.string().register(z.globalRegistry, {
+    description: "The shared text content of the post."
+  }),
+  status: zPostStatus,
+  errorMessage: z.optional(z.string().register(z.globalRegistry, {
+    description: "Human-readable error summary when one or more accounts failed."
+  })),
+  mediaIds: z.optional(z.array(z.uuid()).register(z.globalRegistry, {
+    description: "Media attached to this post."
+  })),
+  deletedMediaCount: z.optional(z.int().check(z.gte(0)).register(z.globalRegistry, {
+    description: "How many media were attached to this post but have since been deleted (rendered as placeholders). Lets a client tell a post that HAD media apart from one posted with none."
+  })),
+  scheduledAt: z.optional(z.iso.datetime().register(z.globalRegistry, {
+    description: "When the post is scheduled to be published."
+  })),
+  publishedAt: z.optional(z.iso.datetime().register(z.globalRegistry, {
+    description: "When the post was published. Present only when all accounts are published."
+  })),
+  createdAt: z.iso.datetime().register(z.globalRegistry, {
+    description: "When the post was created."
+  }),
+  accounts: z.array(zPostAccount).register(z.globalRegistry, {
+    description: "Individual account entries. Each represents the post on one connected social account."
+  })
+});
+var zPostsResponse = z.object({
+  posts: z.array(zPost),
+  pagination: zPagination
+});
+var zCreatePostAccount = z.object({
+  accountId: z.uuid().register(z.globalRegistry, {
+    description: "ID of a connected social account to post to."
+  }),
+  postOverrides: z.optional(z.intersection(zPostOverrides, z.unknown().register(z.globalRegistry, {
+    description: "Override the post-level content or media for this specific account."
+  }))),
+  platformSpecificSettings: z.optional(z.intersection(zPlatformSpecificSettings, z.unknown().register(z.globalRegistry, {
+    description: "Platform-specific settings. The accepted shape depends on the account platform."
+  })))
+});
+var zCreatePostRequest = z.object({
+  content: z._default(z.optional(z.string().register(z.globalRegistry, {
+    description: "The text content of the post, shared across all accounts unless overridden. Optional when media is attached (platform-dependent)."
+  })), ""),
+  mediaIds: z.optional(z.array(z.uuid()).register(z.globalRegistry, {
+    description: "Media to attach to the post. Shared across all accounts unless an account provides its own mediaIds in postOverrides."
+  })),
+  thumbnailTimestamp: z.optional(z.int().check(z.gte(0)).register(z.globalRegistry, {
+    description: "Default video thumbnail timestamp in milliseconds for Instagram and TikTok. Can be overridden per account."
+  })),
+  accounts: z.array(zCreatePostAccount).check(z.minLength(1)).register(z.globalRegistry, {
+    description: "Accounts to post to. Each entry can optionally include content overrides and platform-specific settings."
+  }),
+  scheduledAt: z.optional(z.iso.datetime().register(z.globalRegistry, {
+    description: "Schedule the post for a future date. If omitted and publishNow is false or absent, the post is saved as a draft."
+  })),
+  publishNow: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Publish immediately. Cannot be combined with scheduledAt."
+  }))
+}).register(z.globalRegistry, {
+  description: "Create a post across one or more connected social accounts."
+});
+var zUpdatePostRequest = z.object({
+  content: z.optional(z.string().register(z.globalRegistry, {
+    description: "New shared text content for the post."
+  })),
+  scheduledAt: z.optional(z.iso.datetime().register(z.globalRegistry, {
+    description: "New scheduled date for the post. Must be at least 1 minute in the future."
+  })),
+  mediaIds: z.optional(z.array(z.uuid()).register(z.globalRegistry, {
+    description: "Full replacement for the post media. If omitted, the existing media stays unchanged. If provided, it replaces the current media across all accounts in the post. Send an empty array to remove all media from the post."
+  })),
+  thumbnailTimestamp: z.optional(z.int().check(z.gte(0)).register(z.globalRegistry, {
+    description: "New video thumbnail timestamp in milliseconds for Instagram and TikTok media. Does not change which media files are attached. Combine with mediaIds if you want to replace media and set the new thumbnail timestamp in the same request."
+  })),
+  accounts: z.optional(z.array(zCreatePostAccount).check(z.minLength(1)).register(z.globalRegistry, {
+    description: "Accounts whose content overrides or platform-specific settings should be updated, plus any additional connected accounts to add to the post. Existing accounts omitted from this array remain unchanged and must be removed through the account-specific delete endpoint."
+  })),
+  publishNow: z.optional(z.boolean().register(z.globalRegistry, {
+    description: "Publish an existing draft immediately. Cannot be combined with scheduledAt."
+  }))
+}).register(z.globalRegistry, {
+  description: "Update a draft or scheduled post. Published and publishing posts cannot be updated. Media behavior is explicit: omit mediaIds to keep existing media unchanged, provide mediaIds to replace all current media, or provide an empty mediaIds array to remove all media."
+});
+var zSuccessMessage = z.object({
+  deleted: z.literal(true),
+  id: z.uuid()
+});
+var zAccount = z.object({
+  id: z.uuid().register(z.globalRegistry, {
+    description: "Unique social account identifier in PublishQ."
+  }),
+  platform: z.intersection(zSocialPlatform, z.unknown().register(z.globalRegistry, {
+    description: "Social platform that this connected account belongs to."
+  })),
+  platformName: z.nullish(z.string()),
+  platformUsername: z.string().register(z.globalRegistry, {
+    description: "Primary username or handle on the connected social platform."
+  }),
+  platformUserId: z.string().register(z.globalRegistry, {
+    description: "Unique user or channel identifier provided by the social platform."
+  }),
+  platformPicture: z.nullish(z.string()),
+  workspaceId: z.nullish(z.uuid())
+});
+var zAccountsResponse = z.object({
+  accounts: z.array(zAccount).register(z.globalRegistry, {
+    description: "Connected social accounts visible to the authenticated API key."
+  })
+});
+var zWorkspace = z.object({
+  id: z.uuid().register(z.globalRegistry, {
+    description: "Unique workspace identifier in PublishQ."
+  }),
+  name: z.string().register(z.globalRegistry, {
+    description: "Workspace name shown in the PublishQ UI."
+  }),
+  description: z.nullish(z.string()),
+  color: z.string().register(z.globalRegistry, {
+    description: "Workspace accent color in hex format."
+  }),
+  accountCount: z.int().register(z.globalRegistry, {
+    description: "Number of social accounts assigned to this workspace."
+  }),
+  createdAt: z.iso.datetime().register(z.globalRegistry, {
+    description: "When the workspace was created."
+  })
+});
+var zCreateWorkspaceRequest = z.object({
+  name: z.string().check(z.minLength(1), z.maxLength(50)).register(z.globalRegistry, {
+    description: "Workspace name shown in PublishQ."
+  }),
+  description: z.optional(z.string().check(z.maxLength(500)).register(z.globalRegistry, {
+    description: "Optional short description of the workspace."
+  })),
+  color: z._default(z.optional(z.string().check(z.regex(/^#[0-9A-Fa-f]{6}$/)).register(z.globalRegistry, {
+    description: "Workspace accent color as a hex string like `#6366f1`."
+  })), "#6366f1")
+}).register(z.globalRegistry, {
+  description: "Create a new workspace."
+});
+var zWorkspacesResponse = z.object({
+  workspaces: z.array(zWorkspace).register(z.globalRegistry, {
+    description: "Workspaces visible to the authenticated API key owner."
+  })
+});
+var zMediaType = z.enum(["IMAGE", "VIDEO"]).register(z.globalRegistry, {
+  description: "Media file type."
+});
+var zMediaSource = z.enum([
+  "UPLOAD",
+  "GENERATED",
+  "AI_GENERATED"
+]).register(z.globalRegistry, {
+  description: "How the media was created: uploaded by the user, generated inside PublishQ, or AI-generated inside PublishQ."
+});
+var zMedia = z.object({
+  id: z.uuid().register(z.globalRegistry, {
+    description: "Unique media identifier in PublishQ."
+  }),
+  type: zMediaType,
+  url: z.url().register(z.globalRegistry, {
+    description: "Direct URL to the uploaded or generated media file."
+  }),
+  source: zMediaSource,
+  created_at: z.iso.datetime().register(z.globalRegistry, {
+    description: "When the media item was created in PublishQ."
+  }),
+  usageCount: z.int().register(z.globalRegistry, {
+    description: "Number of posts this media item was used in."
+  })
+});
+var zMediaListResponse = z.object({
+  media: z.array(zMedia),
+  pagination: zPagination
+});
+var zUploadMediaRequest = z.object({
+  file: z.string()
+});
+var zTikTokCreatorInfoResponse = z.object({
+  privacyLevelOptions: z.array(z.string()).register(z.globalRegistry, {
+    description: "Privacy levels available for this account. Use one of these values as `privacyLevel` in `platformSpecificSettings`."
+  }),
+  commentDisabled: z.boolean().register(z.globalRegistry, {
+    description: "True if the creator has disabled comments at the account level."
+  }),
+  duetDisabled: z.boolean().register(z.globalRegistry, {
+    description: "True if the creator has disabled Duets at the account level."
+  }),
+  stitchDisabled: z.boolean().register(z.globalRegistry, {
+    description: "True if the creator has disabled Stitches at the account level."
+  }),
+  maxVideoPostDurationSec: z.number().register(z.globalRegistry, {
+    description: "Maximum video duration in seconds this creator can post (typically 180, 300, or 600)."
+  })
+});
+var zApiKeyScope = z.enum([
+  "posts:read",
+  "posts:write",
+  "accounts:read",
+  "workspaces:read",
+  "workspaces:write",
+  "media:read",
+  "media:write"
+]);
+var zListPostsQuery = z.object({
+  page: z._default(z.optional(z.int().check(z.gt(0)).register(z.globalRegistry, {
+    description: "Page number (starts from 1)."
+  })), 1),
+  limit: z._default(z.optional(z.int().check(z.gt(0), z.lte(100)).register(z.globalRegistry, {
+    description: "Page size. Max 100."
+  })), 20)
+});
+var zListPostsResponse = zPostsResponse;
+var zCreatePostBody = zCreatePostRequest;
+var zCreatePostResponse = zPost;
+var zDeletePostPath = z.object({
+  id: z.uuid()
+});
+var zDeletePostResponse = z.void().register(z.globalRegistry, {
+  description: "Post deleted successfully"
+});
+var zGetPostPath = z.object({
+  id: z.uuid()
+});
+var zGetPostResponse = zPost;
+var zUpdatePostBody = zUpdatePostRequest;
+var zUpdatePostPath = z.object({
+  id: z.uuid()
+});
+var zUpdatePostResponse = zPost;
+var zRemovePostAccountPath = z.object({
+  id: z.uuid(),
+  accountId: z.uuid()
+});
+var zRemovePostAccountResponse = z.void().register(z.globalRegistry, {
+  description: "Account removed from post successfully"
+});
+var zListAccountsQuery = z.object({
+  workspaceId: z.optional(z.uuid().register(z.globalRegistry, {
+    description: "Return only accounts assigned to the specified workspace. If omitted, accounts from all workspaces are returned."
+  })),
+  platform: z.optional(z.array(zSocialPlatform).register(z.globalRegistry, {
+    description: "Return only accounts connected to the specified social platforms. Repeat the parameter to apply OR logic, for example `?platform=twitter&platform=instagram`."
+  }))
+});
+var zListAccountsResponse = zAccountsResponse;
+var zGetTikTokCreatorInfoPath = z.object({
+  id: z.uuid()
+});
+var zGetTikTokCreatorInfoResponse = zTikTokCreatorInfoResponse;
+var zListWorkspacesResponse = zWorkspacesResponse;
+var zCreateWorkspaceBody = zCreateWorkspaceRequest;
+var zCreateWorkspaceResponse = zWorkspace;
+var zGetWorkspacePath = z.object({
+  id: z.uuid()
+});
+var zGetWorkspaceResponse = zWorkspace;
+var zListMediaQuery = z.object({
+  page: z._default(z.optional(z.int().check(z.gt(0)).register(z.globalRegistry, {
+    description: "Page number (starts from 1)."
+  })), 1),
+  limit: z._default(z.optional(z.int().check(z.gt(0), z.lte(100)).register(z.globalRegistry, {
+    description: "Page size. Max 100."
+  })), 20),
+  ids: z.optional(z.array(z.uuid()).register(z.globalRegistry, {
+    description: "Return only the specified media IDs. Repeat the parameter to apply OR logic, for example `?ids=id1&ids=id2`."
+  })),
+  mediaTypes: z.optional(z.array(zMediaType).register(z.globalRegistry, {
+    description: "Return only media items of the specified types. Repeat the parameter to apply OR logic, for example `?mediaTypes=image&mediaTypes=video`."
+  })),
+  sources: z.optional(z.array(zMediaSource).register(z.globalRegistry, {
+    description: "Return only media items from the specified sources. Repeat the parameter to apply OR logic, for example `?sources=upload&sources=ai_generated`."
+  }))
+});
+var zListMediaResponse = zMediaListResponse;
+var zUploadMediaBody = zUploadMediaRequest;
+var zUploadMediaResponse = zMedia;
+var zGetMediaPath = z.object({
+  id: z.uuid()
+});
+var zGetMediaResponse = zMedia;
+
+// src/index.ts
+var rawErrorBodies = /* @__PURE__ */ new WeakMap();
+async function preserveApiError(call) {
+  const result = await call;
+  const response = result.response;
+  const rawBody = response ? rawErrorBodies.get(response) : void 0;
+  if (!response || response.ok || !rawBody) {
+    return result;
+  }
+  const text = await rawBody;
+  if (text.length === 0) {
+    return { ...result, error: void 0 };
+  }
+  let error = text;
+  try {
+    error = JSON.parse(text);
+  } catch {
+  }
+  return { ...result, error };
+}
+var PublishQ = class {
+  /**
+   * Post resources — create, list, retrieve, update, and delete posts across
+   * the connected accounts this API key is scoped to.
+   */
+  posts;
+  /**
+   * Account resources — list connected social accounts and read the TikTok
+   * creator info required before posting to TikTok.
+   */
+  accounts;
+  /**
+   * Workspace resources — list, create, and retrieve the workspaces that
+   * organize your connected accounts.
+   */
+  workspaces;
+  /**
+   * Media resources — upload, list, and retrieve media files you can attach
+   * to posts.
+   */
+  media;
+  constructor(options) {
+    const client2 = createClient(
+      createConfig({
+        baseUrl: options.baseUrl ?? "https://publishq.com/api/v1",
+        headers: {
+          Authorization: `Bearer ${options.apiKey}`
+        }
+      })
+    );
+    client2.interceptors.response.use((response) => {
+      if (!response.ok) {
+        rawErrorBodies.set(response, response.clone().text());
+      }
+      return response;
+    });
+    this.posts = createPostsNamespace(client2);
+    this.accounts = createAccountsNamespace(client2);
+    this.workspaces = createWorkspacesNamespace(client2);
+    this.media = createMediaNamespace(client2);
+  }
+};
+function createPostsNamespace(client2) {
+  return {
+    /** List posts. Optionally filter by status/workspace/account and paginate. Wraps `Posts.listPosts`. */
+    list: (query) => preserveApiError(Posts.listPosts({ client: client2, query })),
+    /** Create a post for one or more connected accounts. Wraps `Posts.createPost`. */
+    create: (body) => preserveApiError(Posts.createPost({ client: client2, body })),
+    /** Get one post by its PublishQ post ID. Wraps `Posts.getPost`. */
+    get: (id) => preserveApiError(Posts.getPost({ client: client2, path: { id } })),
+    /** Update a draft or scheduled post. Wraps `Posts.updatePost`. */
+    update: (id, body) => preserveApiError(Posts.updatePost({ client: client2, path: { id }, body })),
+    /** Delete a scheduled or draft post by its ID. Wraps `Posts.deletePost`. */
+    delete: (id) => preserveApiError(Posts.deletePost({ client: client2, path: { id } })),
+    /** Remove one account from a post so it's no longer published there. Wraps `Posts.removePostAccount`. */
+    removeAccount: (id, accountId) => preserveApiError(
+      Posts.removePostAccount({ client: client2, path: { id, accountId } })
+    )
+  };
+}
+function createAccountsNamespace(client2) {
+  return {
+    /** List connected social accounts. Filter by workspace and platform. Wraps `Accounts.listAccounts`. */
+    list: (query) => preserveApiError(Accounts.listAccounts({ client: client2, query })),
+    /** Get a TikTok account's creator info (privacy options, limits) before posting. Wraps `Accounts.getTikTokCreatorInfo`. */
+    getTikTokCreatorInfo: (id) => preserveApiError(
+      Accounts.getTikTokCreatorInfo({ client: client2, path: { id } })
+    )
+  };
+}
+function createWorkspacesNamespace(client2) {
+  return {
+    /** List your workspaces with names, colors, and account counts. Wraps `Workspaces.listWorkspaces`. */
+    list: () => preserveApiError(Workspaces.listWorkspaces({ client: client2 })),
+    /** Create a workspace to organize your connected accounts. Wraps `Workspaces.createWorkspace`. */
+    create: (body) => preserveApiError(Workspaces.createWorkspace({ client: client2, body })),
+    /** Get one workspace by ID. Wraps `Workspaces.getWorkspace`. */
+    get: (id) => preserveApiError(Workspaces.getWorkspace({ client: client2, path: { id } }))
+  };
+}
+function createMediaNamespace(client2) {
+  return {
+    /** List your uploaded and generated media files. Filter by id, type, source. Wraps `Media.listMedia`. */
+    list: (query) => preserveApiError(Media.listMedia({ client: client2, query })),
+    /** Upload one media file (multipart) and get back a media ID to attach to posts. Wraps `Media.uploadMedia`. */
+    upload: (body) => preserveApiError(Media.uploadMedia({ client: client2, body })),
+    /** Get one media file by ID. Wraps `Media.getMedia`. */
+    get: (id) => preserveApiError(Media.getMedia({ client: client2, path: { id } }))
+  };
+}
+var index_default = PublishQ;
+export {
+  Accounts,
+  Media as Media2,
+  Posts,
+  PublishQ,
+  Workspaces,
+  index_default as default,
+  zAccount,
+  zAccountsResponse,
+  zApiError,
+  zApiErrorCode,
+  zApiKeyScope,
+  zBlueskyPlatformSpecificSettings,
+  zCreatePostAccount,
+  zCreatePostBody,
+  zCreatePostRequest,
+  zCreatePostResponse,
+  zCreateWorkspaceBody,
+  zCreateWorkspaceRequest,
+  zCreateWorkspaceResponse,
+  zDeletePostPath,
+  zDeletePostResponse,
+  zFacebookPlatformSpecificSettings,
+  zGetMediaPath,
+  zGetMediaResponse,
+  zGetPostPath,
+  zGetPostResponse,
+  zGetTikTokCreatorInfoPath,
+  zGetTikTokCreatorInfoResponse,
+  zGetWorkspacePath,
+  zGetWorkspaceResponse,
+  zInstagramPlatformSpecificSettings,
+  zInstagramTrialParams,
+  zLinkedInPlatformSpecificSettings,
+  zListAccountsQuery,
+  zListAccountsResponse,
+  zListMediaQuery,
+  zListMediaResponse,
+  zListPostsQuery,
+  zListPostsResponse,
+  zListWorkspacesResponse,
+  zMedia,
+  zMediaListResponse,
+  zMediaSource,
+  zMediaType,
+  zPagination,
+  zPlatformSpecificSettings,
+  zPost,
+  zPostAccount,
+  zPostOverrides,
+  zPostStatus,
+  zPostsResponse,
+  zRemovePostAccountPath,
+  zRemovePostAccountResponse,
+  zSocialPlatform,
+  zSuccessMessage,
+  zThreadsPlatformSpecificSettings,
+  zTikTokCreatorInfoResponse,
+  zTikTokPlatformSpecificSettings,
+  zTwitterPlatformSpecificSettings,
+  zUpdatePostBody,
+  zUpdatePostPath,
+  zUpdatePostRequest,
+  zUpdatePostResponse,
+  zUploadMediaBody,
+  zUploadMediaRequest,
+  zUploadMediaResponse,
+  zWorkspace,
+  zWorkspacesResponse,
+  zYouTubePlatformSpecificSettings
+};
+//# sourceMappingURL=index.js.map