rotur-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1067 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  AuthError: () => AuthError,
+  Rotur: () => Rotur,
+  RoturSocket: () => RoturSocket,
+  performAuth: () => performAuth
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http.ts
+var ApiError = class extends Error {
+  constructor(status, data) {
+    super(
+      typeof data === "object" && data !== null && "error" in data ? String(data.error) : `API error ${status}`
+    );
+    this.status = status;
+    this.data = data;
+    this.name = "ApiError";
+  }
+  status;
+  data;
+};
+var Http = class {
+  baseUrl = "https://api.rotur.dev";
+  getToken;
+  constructor(getToken) {
+    this.getToken = getToken;
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value === void 0 || value === null) continue;
+        url.searchParams.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : String(value)
+        );
+      }
+    }
+    return url.toString();
+  }
+  async get(path, params, auth = true) {
+    const token = auth ? this.getToken() : null;
+    if (auth && !token)
+      throw new ApiError(401, {
+        error: "Not authenticated \u2014 call rotur.login() first"
+      });
+    const allParams = auth && token ? { ...params, auth: token } : params;
+    const res = await fetch(this.buildUrl(path, allParams));
+    return this.handle(res);
+  }
+  async post(path, body, auth = true) {
+    const token = auth ? this.getToken() : null;
+    if (auth && !token)
+      throw new ApiError(401, {
+        error: "Not authenticated \u2014 call rotur.login() first"
+      });
+    const opts = {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    };
+    if (body !== void 0) opts.body = JSON.stringify(body);
+    const res = await fetch(
+      this.buildUrl(path, auth && token ? { auth: token } : void 0),
+      opts
+    );
+    return this.handle(res);
+  }
+  async patch(path, body) {
+    const token = this.getToken();
+    if (!token) throw new ApiError(401, { error: "Not authenticated" });
+    const opts = {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" }
+    };
+    if (body !== void 0) opts.body = JSON.stringify(body);
+    const res = await fetch(this.buildUrl(path, { auth: token }), opts);
+    return this.handle(res);
+  }
+  async del(path, body) {
+    const token = this.getToken();
+    if (!token) throw new ApiError(401, { error: "Not authenticated" });
+    const opts = {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" }
+    };
+    if (body !== void 0) opts.body = JSON.stringify(body);
+    const res = await fetch(this.buildUrl(path, { auth: token }), opts);
+    return this.handle(res);
+  }
+  async handle(res) {
+    const text = await res.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      if (!res.ok) throw new ApiError(res.status, text);
+      return void 0;
+    }
+    if (!res.ok) throw new ApiError(res.status, data);
+    return data;
+  }
+};
+
+// src/websocket.ts
+var RoturSocket = class extends EventTarget {
+  constructor(url = "wss://api.rotur.dev/status/ws") {
+    super();
+    this.url = url;
+  }
+  url;
+  ws = null;
+  token = null;
+  reconnectTimer = null;
+  heartbeat = null;
+  _connected = false;
+  _userId = null;
+  _username = null;
+  handlers = /* @__PURE__ */ new Map();
+  rooms = /* @__PURE__ */ new Set();
+  get connected() {
+    return this._connected;
+  }
+  get userId() {
+    return this._userId;
+  }
+  get username() {
+    return this._username;
+  }
+  get joinedRooms() {
+    return [...this.rooms];
+  }
+  connect(token) {
+    this.token = token;
+    return new Promise((resolve, reject) => {
+      this.cleanup();
+      this.ws = new WebSocket(this.url);
+      this.ws.onmessage = (e) => {
+        let msg;
+        try {
+          msg = JSON.parse(e.data);
+        } catch {
+          return;
+        }
+        const cmd = msg.cmd;
+        if (cmd === "ready") {
+          this._connected = true;
+          this._userId = msg.user_id;
+          this._username = msg.username;
+          this.startHeartbeat();
+          resolve(msg);
+        }
+        if (cmd === "join_ok") this.rooms.add(msg.room);
+        if (cmd === "leave_ok") this.rooms.delete(msg.room);
+        this.emit(cmd, msg);
+      };
+      this.ws.onerror = (e) => {
+        if (!this._connected) reject(new Error("WebSocket connection failed"));
+        this.emit("error", e);
+      };
+      this.ws.onclose = () => {
+        this._connected = false;
+        this.emit("close", {});
+        this.scheduleReconnect();
+      };
+      this.send({ cmd: "auth", key: token });
+    });
+  }
+  startHeartbeat() {
+    this.heartbeat = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ cmd: "ping" }));
+      }
+    }, 25e3);
+  }
+  scheduleReconnect() {
+    if (!this.token) return;
+    this.reconnectTimer = setTimeout(
+      () => this.connect(this.token).catch(() => {
+      }),
+      3e3
+    );
+  }
+  cleanup() {
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.heartbeat = null;
+    this.reconnectTimer = null;
+  }
+  emit(cmd, msg) {
+    this.handlers.get(cmd)?.forEach((h) => h(msg));
+    this.dispatchEvent(new CustomEvent(cmd, { detail: msg }));
+    this.dispatchEvent(new CustomEvent("*", { detail: msg }));
+  }
+  send(packet) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(packet));
+    }
+  }
+  on(cmd, handler) {
+    if (!this.handlers.has(cmd)) this.handlers.set(cmd, /* @__PURE__ */ new Set());
+    this.handlers.get(cmd).add(handler);
+    return () => this.handlers.get(cmd)?.delete(handler);
+  }
+  off(cmd, handler) {
+    this.handlers.get(cmd)?.delete(handler);
+  }
+  once(cmd) {
+    return new Promise((resolve) => {
+      const h = (msg) => {
+        this.off(cmd, h);
+        resolve(msg);
+      };
+      this.on(cmd, h);
+    });
+  }
+  join(rooms) {
+    this.send({ cmd: "join", rooms: Array.isArray(rooms) ? rooms : [rooms] });
+  }
+  leave(rooms) {
+    this.send({ cmd: "leave", rooms: Array.isArray(rooms) ? rooms : [rooms] });
+  }
+  listRooms() {
+    this.send({ cmd: "rooms" });
+    return this.once("rooms").then((m) => m.rooms);
+  }
+  roomState(room) {
+    this.send({ cmd: "room_state", room });
+  }
+  setPresence(presence) {
+    this.send({ cmd: "set_status", presence });
+  }
+  setStatus(status) {
+    this.send({ cmd: "set_status", status });
+  }
+  addActivity(activity) {
+    this.send({ cmd: "add_activity", ...activity });
+  }
+  removeActivity(id) {
+    this.send({ cmd: "remove_activity", id });
+  }
+  setMusic(application, media, title) {
+    this.send({
+      cmd: "add_activity",
+      id: application,
+      title: title ?? `Listening to ${application}`,
+      application: { name: application },
+      media
+    });
+  }
+  setPlaying(application, options) {
+    this.send({
+      cmd: "add_activity",
+      id: application,
+      title: options?.title ?? application,
+      application: { name: application, url: options?.url },
+      status: options?.status,
+      image: options?.image
+    });
+  }
+  clearActivity(id) {
+    this.send({ cmd: "remove_activity", id });
+  }
+  disconnect() {
+    this.token = null;
+    this.cleanup();
+    this.rooms.clear();
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this._connected = false;
+  }
+};
+
+// src/auth.ts
+var AUTH_URL = "https://rotur.dev/auth";
+var ORIGIN = "https://rotur.dev";
+var AuthError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AuthError";
+  }
+  code;
+};
+function performAuth(options) {
+  if (options?.signal?.aborted) {
+    throw new AuthError("aborted", "Auth was aborted");
+  }
+  const timeout = options?.timeout ?? 12e4;
+  const authUrl = new URL(AUTH_URL);
+  if (options?.system) authUrl.searchParams.set("system", options.system);
+  let iframe;
+  return new Promise((resolve, reject) => {
+    const signal = options?.signal;
+    const rejectWithError = (code, msg) => {
+      cleanup();
+      reject(new AuthError(code, msg));
+    };
+    const timer = setTimeout(() => {
+      rejectWithError("timeout", `Auth timed out after ${timeout}ms`);
+    }, timeout);
+    const onAbort = () => rejectWithError("aborted", "Auth was aborted");
+    signal?.addEventListener("abort", onAbort, { once: true });
+    function handler(e) {
+      if (e.origin !== ORIGIN) return;
+      if (e.data?.type !== "rotur-auth-token") return;
+      if (!e.data.token) return;
+      cleanup();
+      resolve({ token: e.data.token });
+    }
+    function cleanup() {
+      clearTimeout(timer);
+      window.removeEventListener("message", handler);
+      signal?.removeEventListener("abort", onAbort);
+      iframe?.remove();
+    }
+    window.addEventListener("message", handler);
+    const w = window.open(
+      authUrl.toString(),
+      "rotur-auth",
+      "width=480,height=720"
+    );
+    if (w) return;
+    iframe = document.createElement("iframe");
+    iframe.style.cssText = "position:fixed;inset:0;width:100%;height:100%;border:none;z-index:9999";
+    iframe.src = authUrl.toString();
+    document.body.appendChild(iframe);
+  });
+}
+
+// src/client.ts
+var Rotur = class {
+  _token = null;
+  _http;
+  socket;
+  me = new MeNamespace(this);
+  posts = new PostsNamespace(this);
+  friends = new FriendsNamespace(this);
+  following = new FollowingNamespace(this);
+  notifications = new NotificationsNamespace(this);
+  keys = new KeysNamespace(this);
+  items = new ItemsNamespace(this);
+  gifts = new GiftsNamespace(this);
+  tokens = new TokensNamespace(this);
+  groups = new GroupsNamespace(this);
+  systems = new SystemsNamespace(this);
+  stats = new StatsNamespace(this);
+  status = new StatusNamespace(this);
+  validators = new ValidatorsNamespace(this);
+  link = new LinkNamespace(this);
+  cosmetics = new CosmeticsNamespace(this);
+  push = new PushNamespace(this);
+  files = new FilesNamespace(this);
+  standing = new StandingNamespace(this);
+  profiles = new ProfilesNamespace(this);
+  devfund = new DevFundNamespace(this);
+  check = new CheckNamespace(this);
+  constructor(options) {
+    this._token = options?.token ?? null;
+    this._http = new Http(() => this._token);
+    this.socket = new RoturSocket(options?.wsUrl);
+  }
+  get token() {
+    return this._token;
+  }
+  get loggedIn() {
+    return this._token !== null;
+  }
+  setToken(token) {
+    this._token = token;
+  }
+  async login(options) {
+    const { token } = await performAuth(options);
+    this._token = token;
+    return this;
+  }
+  async connectSocket() {
+    if (!this._token) throw new ApiError(401, { error: "Login first" });
+    return this.socket.connect(this._token);
+  }
+  logout() {
+    this._token = null;
+    this.socket.disconnect();
+  }
+};
+var Namespace = class {
+  constructor(r) {
+    this.r = r;
+  }
+  r;
+  $get(path, params, auth = true) {
+    return this.r._http.get(path, params, auth);
+  }
+  $post(path, body, auth = true) {
+    return this.r._http.post(path, body, auth);
+  }
+  $patch(path, body) {
+    return this.r._http.patch(path, body);
+  }
+  $del(path, body) {
+    return this.r._http.del(path, body);
+  }
+};
+var ProfilesNamespace = class extends Namespace {
+  async get(username, includePosts = true) {
+    return this.$get(
+      "/profile",
+      { username, include_posts: includePosts ? "1" : "0" },
+      false
+    );
+  }
+  async exists(username) {
+    return this.$get("/exists", { username }, false);
+  }
+  async supporters() {
+    return this.$get("/supporters", void 0, false);
+  }
+  getAvatarUrl(username, cache = "") {
+    return `https://avatars.rotur.dev/${username}?v=${cache}`;
+  }
+};
+var MeNamespace = class extends Namespace {
+  async get() {
+    return this.$get("/me");
+  }
+  async update(key, value) {
+    return this.$post("/me/update", { key, value });
+  }
+  async deleteKey(key) {
+    return this.$del("/me/delete", { key });
+  }
+  async deleteAccount() {
+    return this.$del("/users");
+  }
+  async refreshToken() {
+    return this.$post("/me/refresh_token");
+  }
+  async transfer(to, amount, note) {
+    return this.$post("/me/transfer", { to, amount, note });
+  }
+  async claimDaily() {
+    return this.$get("/claim_daily");
+  }
+  async claimTime() {
+    return this.$get("/claim_time");
+  }
+  async badges() {
+    return this.$get("/badges");
+  }
+  async acceptTos() {
+    return this.$post("/accept_tos");
+  }
+  async abilities() {
+    return this.$get("/me/able");
+  }
+  async blocked() {
+    return this.$get("/me/blocked");
+  }
+  async block(username) {
+    return this.$post(`/me/block/${username}`);
+  }
+  async unblock(username) {
+    return this.$post(`/me/unblock/${username}`);
+  }
+  async note(username, content) {
+    return this.$post(`/me/note/${username}`, { content });
+  }
+  async deleteNote(username) {
+    return this.$del(`/me/note/${username}`);
+  }
+  async resendVerification() {
+    return this.$post("/me/resend_verification");
+  }
+  async verifyEmail(token) {
+    return this.$get("/verify_email", { token }, false);
+  }
+  async checkAuth() {
+    return this.$get("/check_auth");
+  }
+  async requests() {
+    return this.$get("/me", void 0).then((u) => ({
+      requests: u["sys.requests"] ?? []
+    }));
+  }
+  async transactions() {
+    return this.$get("/me", void 0).then((u) => u["sys.transactions"] ?? []);
+  }
+  async subscription() {
+    return this.$get("/me", void 0).then((u) => u["sys.subscription"] ?? { active: false, tier: "Free", next_billing: 0 });
+  }
+};
+var PostsNamespace = class extends Namespace {
+  async create(content, options) {
+    const params = { content };
+    if (options?.attachment) params.attachment = options.attachment;
+    if (options?.profileOnly) params.profile_only = "1";
+    if (options?.os) params.os = options.os;
+    return this.$get("/post", params);
+  }
+  async delete(id) {
+    return this.$get("/delete", { id });
+  }
+  async like(id) {
+    return this.$get("/rate", { id, rating: 1 });
+  }
+  async unlike(id) {
+    return this.$get("/rate", { id, rating: 0 });
+  }
+  async reply(id, content) {
+    return this.$get("/reply", { id, content });
+  }
+  async repost(id) {
+    return this.$get("/repost", { id });
+  }
+  async pin(id) {
+    return this.$get("/pin_post", { id });
+  }
+  async unpin(id) {
+    return this.$get("/unpin_post", { id });
+  }
+  async feed(limit = 100, offset = 0) {
+    return this.$get("/feed", { limit, offset }, false);
+  }
+  async followingFeed(limit = 100) {
+    return this.$get("/following_feed", { limit });
+  }
+  async top(limit = 50, timePeriod = 24) {
+    return this.$get("/top_posts", { limit, time_period: timePeriod }, false);
+  }
+  async search(query, limit = 20) {
+    return this.$get("/search_posts", { q: query, limit }, false);
+  }
+  async limits() {
+    return this.$get("/limits", void 0, false);
+  }
+};
+var FriendsNamespace = class extends Namespace {
+  async list() {
+    return this.$get("/friends");
+  }
+  async request(username) {
+    return this.$post(`/friends/request/${username}`);
+  }
+  async accept(username) {
+    return this.$post(`/friends/accept/${username}`);
+  }
+  async reject(username) {
+    return this.$post(`/friends/reject/${username}`);
+  }
+  async remove(username) {
+    return this.$post(`/friends/remove/${username}`);
+  }
+};
+var FollowingNamespace = class extends Namespace {
+  async follow(username) {
+    return this.$get("/follow", { username });
+  }
+  async unfollow(username) {
+    return this.$get("/unfollow", { username });
+  }
+  async followers(username) {
+    return this.$get("/followers", { username }, false);
+  }
+  async following(username) {
+    return this.$get("/following", { username }, false);
+  }
+};
+var NotificationsNamespace = class extends Namespace {
+  async list(afterDays = 1) {
+    return this.$get("/notifications", { after: afterDays });
+  }
+};
+var KeysNamespace = class extends Namespace {
+  async create(name, options) {
+    const params = { name };
+    if (options?.description) params.description = options.description;
+    if (options?.price !== void 0) params.price = String(options.price);
+    if (options?.subscription) params.subscription = "true";
+    if (options?.frequency) params.frequency = String(options.frequency);
+    if (options?.period) params.period = options.period;
+    return this.$get("/keys/create", params);
+  }
+  async mine() {
+    return this.$get("/keys/mine");
+  }
+  async get(id) {
+    return this.$get(`/keys/get/${id}`, void 0, false);
+  }
+  async check(username, key) {
+    return this.$get(`/keys/check/${username}`, { key }, false);
+  }
+  async rename(id, name) {
+    return this.$get(`/keys/name/${id}`, { name });
+  }
+  async update(id, key, data) {
+    return this.$get(`/keys/update/${id}`, { key, data });
+  }
+  async revoke(id, user) {
+    return this.$get(`/keys/revoke/${id}`, { user });
+  }
+  async delete(id) {
+    return this.$get(`/keys/delete/${id}`);
+  }
+  async addUser(id, user) {
+    return this.$get(`/keys/admin_add/${id}`, { user });
+  }
+  async removeUser(id, user) {
+    return this.$get(`/keys/admin_remove/${id}`, { user });
+  }
+  async buy(id) {
+    return this.$get(`/keys/buy/${id}`);
+  }
+  async cancel(id) {
+    return this.$get(`/keys/cancel/${id}`);
+  }
+};
+var ItemsNamespace = class extends Namespace {
+  async create(item) {
+    return this.$get("/items/create", { item: JSON.stringify(item) });
+  }
+  async get(name) {
+    return this.$get(`/items/get/${name}`, void 0, false);
+  }
+  async list(username) {
+    return this.$get(`/items/list/${username}`, void 0, false);
+  }
+  async selling(limit = 50) {
+    return this.$get("/items/selling", { limit }, false);
+  }
+  async buy(name) {
+    return this.$get(`/items/buy/${name}`);
+  }
+  async transfer(name, username) {
+    return this.$get(`/items/transfer/${name}`, { username });
+  }
+  async sell(name) {
+    return this.$get(`/items/sell/${name}`);
+  }
+  async stopSelling(name) {
+    return this.$get(`/items/stop_selling/${name}`);
+  }
+  async setPrice(name, price) {
+    return this.$get(`/items/set_price/${name}`, { price: String(price) });
+  }
+  async update(name, data) {
+    return this.$get(`/items/update/${name}`, { data: JSON.stringify(data) });
+  }
+  async delete(name) {
+    return this.$get(`/items/delete/${name}`);
+  }
+};
+var GiftsNamespace = class extends Namespace {
+  async create(amount, options) {
+    return this.$post("/gifts/create", {
+      amount,
+      note: options?.note,
+      expires_in_hrs: options?.expiresInHrs
+    });
+  }
+  async get(code) {
+    return this.$get(`/gifts/${code}`, void 0, false);
+  }
+  async claim(code) {
+    return this.$post(`/gifts/claim/${code}`);
+  }
+  async cancel(id) {
+    return this.$post(`/gifts/cancel/${id}`);
+  }
+  async mine() {
+    return this.$get("/gifts/mine");
+  }
+};
+var TokensNamespace = class extends Namespace {
+  async permissions() {
+    return this.$get("/tokens/permissions", void 0, false);
+  }
+  async list() {
+    return this.$get("/tokens");
+  }
+  async active() {
+    return this.$get("/tokens/active");
+  }
+  async create(name, permissions, options) {
+    return this.$post("/tokens/create", {
+      name,
+      permissions,
+      expires_in_hrs: options?.expiresInHrs,
+      origin: options?.origin,
+      description: options?.description,
+      websites: options?.websites
+    });
+  }
+  async get(id) {
+    return this.$get(`/tokens/${id}`);
+  }
+  async activity(id) {
+    return this.$get(`/tokens/${id}/activity`);
+  }
+  async update(id, options) {
+    return this.$patch(`/tokens/${id}`, options);
+  }
+  async rename(id, name) {
+    return this.$post(`/tokens/${id}/rename`, { name });
+  }
+  async revoke(id) {
+    return this.$post(`/tokens/${id}/revoke`);
+  }
+  async delete(id) {
+    return this.$del(`/tokens/${id}`);
+  }
+};
+var GroupsNamespace = class extends Namespace {
+  async mine() {
+    return this.$get("/groups/mine");
+  }
+  async search(query) {
+    return this.$get("/groups/search", { query });
+  }
+  async create(tag, name, options) {
+    const params = { tag, name };
+    if (options?.description) params.description = options.description;
+    if (options?.iconUrl) params.icon_url = options.iconUrl;
+    if (options?.bannerUrl) params.banner_url = options.bannerUrl;
+    if (options?.public !== void 0) params.public = String(options.public);
+    if (options?.joinPolicy) params.join_policy = options.joinPolicy;
+    return this.$post("/groups/create", params);
+  }
+  async get(grouptag) {
+    return this.$get(`/groups/${grouptag}`);
+  }
+  async update(grouptag, updates) {
+    return this.$patch(`/groups/${grouptag}`, updates);
+  }
+  async delete(grouptag) {
+    return this.$del(`/groups/${grouptag}`);
+  }
+  async join(grouptag) {
+    return this.$post(`/groups/${grouptag}/join`);
+  }
+  async leave(grouptag) {
+    return this.$post(`/groups/${grouptag}/leave`);
+  }
+  async represent(grouptag) {
+    return this.$post(`/groups/${grouptag}/rep`);
+  }
+  async disrepresent(grouptag) {
+    return this.$post(`/groups/${grouptag}/disrep`);
+  }
+  async report(grouptag) {
+    return this.$post(`/groups/${grouptag}/report`);
+  }
+  async announcements(grouptag) {
+    return this.$get(`/groups/${grouptag}/announcements`, void 0, false);
+  }
+  async createAnnouncement(grouptag, title, body, options) {
+    return this.$post(`/groups/${grouptag}/announcements`, {
+      title,
+      body,
+      ping_members: options?.pingMembers
+    });
+  }
+  async deleteAnnouncement(grouptag, id) {
+    return this.$del(`/groups/${grouptag}/announcements/${id}`);
+  }
+  async muteAnnouncements(grouptag) {
+    return this.$post(`/groups/${grouptag}/announcements/mute`);
+  }
+  async events(grouptag) {
+    return this.$get(`/groups/${grouptag}/events`);
+  }
+  async createEvent(grouptag, event) {
+    return this.$post(`/groups/${grouptag}/events`, event);
+  }
+  async tips(grouptag) {
+    return this.$get(`/groups/${grouptag}/tips`);
+  }
+  async sendTip(grouptag, amount) {
+    return this.$post(`/groups/${grouptag}/tips`, { amount });
+  }
+  async roles(grouptag) {
+    return this.$get(`/groups/${grouptag}/roles`);
+  }
+  async createRole(grouptag, role) {
+    return this.$post(`/groups/${grouptag}/roles`, role);
+  }
+  async updateRole(grouptag, roleId, updates) {
+    return this.$patch(`/groups/${grouptag}/roles/${roleId}`, updates);
+  }
+  async deleteRole(grouptag, roleId) {
+    return this.$del(`/groups/${grouptag}/roles/${roleId}`);
+  }
+  async userRoles(grouptag, userId) {
+    return this.$get(`/groups/${grouptag}/members/${userId}/roles`);
+  }
+  async userPermissions(grouptag, userId) {
+    return this.$get(`/groups/${grouptag}/members/${userId}/permissions`);
+  }
+  async userBenefits(grouptag, userId) {
+    return this.$get(`/groups/${grouptag}/members/${userId}/benefits`);
+  }
+  async assignRole(grouptag, userId, roleId) {
+    return this.$post(`/groups/${grouptag}/members/${userId}/roles/${roleId}`);
+  }
+  async removeRole(grouptag, userId, roleId) {
+    return this.$del(`/groups/${grouptag}/members/${userId}/roles/${roleId}`);
+  }
+};
+var SystemsNamespace = class extends Namespace {
+  async list() {
+    return this.$get("/systems", void 0, false);
+  }
+  async users(system) {
+    return this.$get("/system/users", { system });
+  }
+  async update(system, key, value) {
+    return this.$post("/update_system", { system, key, value });
+  }
+  async reload() {
+    return this.$get("/reload_systems");
+  }
+};
+var StatsNamespace = class extends Namespace {
+  async economy() {
+    return this.$get("/stats/economy", void 0, false);
+  }
+  async users() {
+    return this.$get("/stats/users", void 0, false);
+  }
+  async mostGained(max = 10) {
+    return this.$get("/stats/most_gained", { max: String(max) }, false);
+  }
+  async systems() {
+    return this.$get("/stats/systems", void 0, false);
+  }
+  async followers(max = 10) {
+    return this.$get("/stats/followers", { max: String(max) }, false);
+  }
+};
+var StatusNamespace = class extends Namespace {
+  async get(username) {
+    return this.$get("/status/get", { name: username }, false);
+  }
+};
+var ValidatorsNamespace = class extends Namespace {
+  async generate(key) {
+    return this.$get("/generate_validator", { key });
+  }
+  async validate(validator, key) {
+    return this.$get("/validate", { v: validator, key }, false);
+  }
+};
+var LinkNamespace = class extends Namespace {
+  async getCode() {
+    return this.$get("/link/code", void 0, false);
+  }
+  async status(code) {
+    return this.$get("/link/status", { code }, false);
+  }
+  async linkedUser(code) {
+    return this.$get("/link/user", { code }, false);
+  }
+  async linkCode(code) {
+    return this.$post("/link/code", { code });
+  }
+  async pollUntilLinked(code, intervalMs = 1500, timeoutMs = 12e4) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const res = await this.$get(
+        "/link/user",
+        { code },
+        false
+      );
+      if (res.linked && res.token) {
+        this.r.setToken(res.token);
+        return res.token;
+      }
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new Error("Link polling timed out");
+  }
+};
+var CosmeticsNamespace = class extends Namespace {
+  async shop(options) {
+    const params = {};
+    if (options?.type) params.type = options.type;
+    if (options?.featured) params.featured = "true";
+    if (options?.search) params.search = options.search;
+    if (options?.sort) params.sort = options.sort;
+    if (options?.limit !== void 0) params.limit = String(options.limit);
+    if (options?.offset !== void 0) params.offset = String(options.offset);
+    return this.$get("/cosmetics/shop", params, false);
+  }
+  async get(id) {
+    return this.$get(`/cosmetics/items/${id}`, void 0, false);
+  }
+  async mine() {
+    return this.$get("/cosmetics/mine");
+  }
+  async purchase(id) {
+    return this.$post(`/cosmetics/purchase/${id}`);
+  }
+  async equip(id) {
+    return this.$post(`/cosmetics/equip/${id}`);
+  }
+  async unequip(type) {
+    return this.$post(`/cosmetics/unequip?type=${encodeURIComponent(type)}`);
+  }
+  async overlays(filepath) {
+    return this.$get(`/cosmetics/overlays/${filepath}`, void 0, false);
+  }
+  /** Admin: List all cosmetics in catalog */
+  async adminList(options) {
+    return this.$get("/cosmetics/admin/list", options, true);
+  }
+  /** Admin: Create a cosmetic */
+  async adminCreate(data) {
+    return this.$post("/cosmetics/admin/create", data);
+  }
+  /** Admin: Update a cosmetic */
+  async adminUpdate(id, data) {
+    return this.$patch(`/cosmetics/admin/update/${id}`, data);
+  }
+  /** Admin: Delete a cosmetic */
+  async adminDelete(id) {
+    return this.$del(`/cosmetics/admin/delete/${id}`);
+  }
+};
+var PushNamespace = class extends Namespace {
+  async vapidKeys() {
+    return this.$get("/notify/vapid", void 0, false);
+  }
+  async register(endpoint, p256dh, auth, source, fingerprint) {
+    return this.$post("/notify/register", {
+      endpoint,
+      p256dh,
+      auth,
+      source,
+      fingerprint
+    });
+  }
+  async check(source, fingerprint) {
+    return this.$get("/notify/check", { source, fingerprint });
+  }
+  async endpoints() {
+    return this.$get("/notify/endpoints");
+  }
+  async deleteDevice(deviceId) {
+    return this.$del(`/notify/device/${deviceId}`);
+  }
+  async allowedSenders() {
+    return this.$get("/notify/allowed");
+  }
+  async allowSender(username, source) {
+    return this.$post(`/notify/allowed/${username}`, { source });
+  }
+  async removeSender(username, source) {
+    return this.$del(`/notify/allowed/${username}`, { source });
+  }
+  async log() {
+    return this.$get("/notify/log");
+  }
+  async send(username, source, options) {
+    return this.$post(`/notify/${username}`, {
+      source,
+      title: options?.title,
+      body: options?.body,
+      data: options?.data
+    });
+  }
+  async sendMany(users, source, options) {
+    return this.$post("/notify/", {
+      source,
+      title: options?.title,
+      body: options?.body,
+      data: options?.data,
+      users
+    });
+  }
+  async notifiableUsers(source) {
+    return this.$get(`/notify/${source}/users`);
+  }
+};
+var FilesNamespace = class extends Namespace {
+  async index() {
+    return this.$get("/files/index");
+  }
+  async all() {
+    return this.$get("/files/entries");
+  }
+  async getByUUID(uuid) {
+    return this.$get("/files", { uuid });
+  }
+  async getByPath(path) {
+    return this.$get(`/files/by-path/${path}`);
+  }
+  async usage() {
+    return this.$get("/files/usage");
+  }
+  async stats(uuids) {
+    return this.$post("/files/stats", { uuids });
+  }
+  async byUUIDs(uuids) {
+    return this.$post("/files/by-uuid", { uuids });
+  }
+  async pathIndex() {
+    return this.$get("/files/path-index");
+  }
+  async upload(files) {
+    return this.$post("/files", files);
+  }
+  async deleteAll() {
+    return this.$del("/files");
+  }
+};
+var StandingNamespace = class extends Namespace {
+  async get(username) {
+    return this.$get("/get_standing", { username }, false);
+  }
+};
+var DevFundNamespace = class extends Namespace {
+  /** Transfer credits to escrow for a dev fund petition */
+  async escrowTransfer(amount, petitionId, note) {
+    return this.$post("/devfund/escrow_transfer", { amount, petition_id: petitionId, note });
+  }
+  /** Release escrow credits to a developer (admin only) */
+  async escrowRelease(amount, toUsername, petitionId, note) {
+    return this.$post("/devfund/escrow_release", { amount, to_username: toUsername, petition_id: petitionId, note });
+  }
+};
+var CheckNamespace = class extends Namespace {
+  /** Check if a list of usernames are banned */
+  async banned(usernames) {
+    return this.$post("/check/banned", usernames.join(","));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AuthError,
+  Rotur,
+  RoturSocket,
+  performAuth
+});