Build with PocketPass

let currentAccessToken = "YOUR_USER_ACCESS_TOKEN";
class ApiError extends Error {
  constructor(status, data, retryAfter) {
    super(data.message || data.error_description || `HTTP ${status}`);
    this.status = status; this.data = data; this.retryAfter = retryAfter;
  }
}
async function requestJson(url, body, contentType = "application/json") {
  const response = await fetch(url, {
    method: "POST",
    headers: { "Content-Type": contentType,
      ...(!new URL(url).pathname.startsWith("/auth/v1/oauth/") ? { Authorization: `Bearer ${currentAccessToken}` } : {}) },
    body: contentType === "application/json" ? JSON.stringify(body) : body.toString()
  });
  const text = await response.text();
  let data;
  try { data = text ? JSON.parse(text) : {}; }
  catch { data = { message: `HTTP ${response.status}: unexpected response` }; }
  if (!response.ok) throw new ApiError(response.status, data, response.headers.get("Retry-After"));
  return data;
}
async function api(endpoint, body = {}) {
  return requestJson(`https://api.pocketpass.xyz/v1/${endpoint}`, body);
}
const session = await api("session.get");
// Use session.scopes to decide which features to show.

import org.json.JSONObject
import org.json.JSONArray
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder

var currentAccessToken = "YOUR_USER_ACCESS_TOKEN"
class ApiError(val status: Int, val data: JSONObject, val retryAfter: String?) :
    Exception(data.optString("message", "HTTP $status"))

// Blocking: run on an IO/background thread. Do not log tokens or responses.
fun requestJson(url: String, body: String, contentType: String = "application/json"): JSONObject {
    val connection = URL(url).openConnection() as HttpURLConnection
    try {
        connection.requestMethod = "POST"
        connection.connectTimeout = 15000
        connection.readTimeout = 30000
        connection.instanceFollowRedirects = false
        connection.doOutput = true
        if (!URL(url).path.startsWith("/auth/v1/oauth/")) {
            connection.setRequestProperty("Authorization", "Bearer $currentAccessToken")
        }
        connection.setRequestProperty("Content-Type", contentType)
        connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
        val status = connection.responseCode
        val stream = if (status in 200..299) connection.inputStream else connection.errorStream
        val text = stream?.bufferedReader()?.use { it.readText() }.orEmpty()
        val data = try { JSONObject(text.ifBlank { "{}" }) }
            catch (_: Exception) { JSONObject().put("message", "HTTP $status: unexpected response") }
        if (status !in 200..299) throw ApiError(status, data, connection.getHeaderField("Retry-After"))
        return data
    } finally { connection.disconnect() }
}
fun api(endpoint: String, body: JSONObject = JSONObject()): JSONObject =
    requestJson("https://api.pocketpass.xyz/v1/$endpoint", body.toString())
fun form(values: Map<String, String>): String = values.entries.joinToString("&") {
    URLEncoder.encode(it.key, "UTF-8") + "=" + URLEncoder.encode(it.value, "UTF-8")
}
val session = api("session.get")
// Use session.getJSONArray("scopes") to decide which features to show.

const clientId = "YOUR_CLIENT_ID";
const redirectUri = "https://your-app.example/callback";
const base64url = bytes => btoa(String.fromCharCode(...bytes)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
const verifier = base64url(crypto.getRandomValues(new Uint8Array(32)));
const state = base64url(crypto.getRandomValues(new Uint8Array(32)));
const challenge = base64url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))));
sessionStorage.setItem("pendingOAuth", JSON.stringify({ verifier, state, redirectUri }));
const params = new URLSearchParams({ client_id: clientId, redirect_uri: redirectUri,
  response_type: "code", scope: "openid", state, code_challenge: challenge, code_challenge_method: "S256" });
location.assign(`https://api.pocketpass.xyz/auth/v1/oauth/authorize?${params}`);

// In the callback page, using the shared requestJson helper:
const pending = JSON.parse(sessionStorage.getItem("pendingOAuth") || "null");
const callback = new URL(location.href);
if (!pending || callback.searchParams.get("state") !== pending.state) throw new Error("Invalid OAuth state");
if (callback.searchParams.has("error")) throw new Error(callback.searchParams.get("error"));
const code = callback.searchParams.get("code");
if (!code) throw new Error("Missing authorization code");
const tokens = await requestJson("https://api.pocketpass.xyz/auth/v1/oauth/token", new URLSearchParams({
  grant_type: "authorization_code", client_id: clientId, code,
  redirect_uri: pending.redirectUri, code_verifier: pending.verifier
}), "application/x-www-form-urlencoded");
currentAccessToken = tokens.access_token;
sessionStorage.removeItem("pendingOAuth");
// Store tokens according to your platform's secure-session design.

import java.security.SecureRandom
import java.security.MessageDigest
import java.util.Base64
import android.net.Uri

val clientId = "YOUR_CLIENT_ID"
val redirectUri = "yourapp://oauth/callback" // Register exactly this URI first.
fun randomUrlToken(): String = Base64.getUrlEncoder().withoutPadding().encodeToString(
    ByteArray(32).also { SecureRandom().nextBytes(it) })
val verifier = randomUrlToken()
val state = randomUrlToken()
val challenge = Base64.getUrlEncoder().withoutPadding().encodeToString(
    MessageDigest.getInstance("SHA-256").digest(verifier.toByteArray(Charsets.US_ASCII)))
val authorizeUrl = "https://api.pocketpass.xyz/auth/v1/oauth/authorize?" + form(mapOf(
    "client_id" to clientId, "redirect_uri" to redirectUri, "response_type" to "code",
    "scope" to "openid", "state" to state, "code_challenge" to challenge, "code_challenge_method" to "S256"))
// Persist verifier/state/redirectUri privately, then launch authorizeUrl in the system browser.

// In your redirect handler, restore the persisted values first:
fun finishLogin(callbackUrl: String, expectedState: String, savedVerifier: String): JSONObject {
    val callback = Uri.parse(callbackUrl)
    val expected = Uri.parse(redirectUri)
    require(callback.scheme == expected.scheme && callback.authority == expected.authority && callback.path == expected.path)
    require(callback.getQueryParameter("state") == expectedState) { "Invalid OAuth state" }
    require(callback.getQueryParameter("error") == null) { "Authorization rejected" }
    val code = requireNotNull(callback.getQueryParameter("code"))
    return requestJson("https://api.pocketpass.xyz/auth/v1/oauth/token", form(mapOf(
        "grant_type" to "authorization_code", "client_id" to clientId, "code" to code,
        "redirect_uri" to redirectUri, "code_verifier" to savedVerifier)), "application/x-www-form-urlencoded")
}
// Run exchange on an IO thread; securely store returned tokens and clear pending state.

const refreshed = await requestJson("https://api.pocketpass.xyz/auth/v1/oauth/token",
  new URLSearchParams({ grant_type: "refresh_token", client_id: "YOUR_CLIENT_ID", refresh_token: savedRefreshToken }),
  "application/x-www-form-urlencoded");
currentAccessToken = refreshed.access_token;
// Atomically replace saved access and refresh tokens, then reauthenticate Realtime.
// When the user explicitly disconnects:
await api("session.revoke");
// Clear local tokens and leave all Realtime channels.

val refreshed = requestJson("https://api.pocketpass.xyz/auth/v1/oauth/token", form(mapOf(
    "grant_type" to "refresh_token", "client_id" to "YOUR_CLIENT_ID", "refresh_token" to savedRefreshToken
)), "application/x-www-form-urlencoded")
currentAccessToken = refreshed.getString("access_token")
// Atomically replace saved access and refresh tokens, then reauthenticate Realtime.
// When the user explicitly disconnects:
api("session.revoke")
// Clear local tokens and leave all Realtime channels.

async function walk(endpoint, filters, byId) {
  let cursor = null;
  do {
    const page = await api(endpoint, { ...filters, limit: 50, ...(cursor ? { cursor } : {}) });
    for (const item of page.items) byId.set(item.id, item);
    cursor = page.next_cursor;
  } while (cursor);
}
const catchUpFrom = new Date(Date.now() - 60000).toISOString();
const conversations = new Map();
await walk("conversations.list", {}, conversations);
await walk("conversations.list", { updated_after: catchUpFrom }, conversations);
for (const conversation of conversations.values()) renderConversation(conversation);
// For message edits/deletions since your saved watermark:
const changes = await api("messages.list", { conversation_id: conversationId, changed_since: savedWatermark });
// Continue through changes.next_cursor too; apply deleted_at markers to your cache.

fun walk(endpoint: String, filters: JSONObject, byId: MutableMap<String, JSONObject>) {
    var cursor: String? = null
    do {
        val body = JSONObject(filters.toString()).put("limit", 50)
        cursor?.let { body.put("cursor", it) }
        val page = api(endpoint, body)
        val items = page.getJSONArray("items")
        for (i in 0 until items.length()) items.getJSONObject(i).let { byId[it.getString("id")] = it }
        cursor = if (page.isNull("next_cursor")) null else page.getString("next_cursor")
    } while (cursor != null)
}
val catchUpFrom = java.time.Instant.now().minusSeconds(60).toString()
val conversations = LinkedHashMap<String, JSONObject>()
walk("conversations.list", JSONObject(), conversations)
walk("conversations.list", JSONObject().put("updated_after", catchUpFrom), conversations)
conversations.values.forEach { renderConversation(it) }
val changes = api("messages.list", JSONObject()
    .put("conversation_id", conversationId).put("changed_since", savedWatermark))
// Continue through next_cursor too; apply deleted_at markers to your cache.

const [low, high] = [myUserId.toLowerCase(), friendUserId.toLowerCase()].sort();
const topic = `friend-presence:${low}:${high}`;
const join = {
  topic: `realtime:${topic}`, event: "phx_join", ref: "1", join_ref: "1",
  payload: { access_token: currentAccessToken,
    config: { private: true, broadcast: { self: false }, presence: { enabled: true, key: myUserId } } }
};
// websocket.send(JSON.stringify(join));
// Requires friends:read + presence:read and an accepted friendship.
// Keep myUserId as the presence key even when friendUserId sorts first.
// Track only with presence:write, after the successful join:
const track = { topic: join.topic, event: "presence", ref: "2", join_ref: "1",
  payload: { type: "presence", event: "track", payload: { user_id: myUserId } } };
// websocket.send(JSON.stringify(track));

fun friendPresenceTopic(me: String, friend: String): String {
    val (low, high) = listOf(me.trim().lowercase(), friend.trim().lowercase()).sorted()
    return "friend-presence:$low:$high"
}
val topic = "realtime:${friendPresenceTopic(myUserId, friendUserId)}"
val join = JSONObject().put("topic", topic).put("event", "phx_join").put("ref", "1").put("join_ref", "1")
    .put("payload", JSONObject().put("access_token", currentAccessToken).put("config", JSONObject()
        .put("private", true).put("broadcast", JSONObject().put("self", false))
        .put("presence", JSONObject().put("enabled", true).put("key", myUserId))))
// websocket.send(join.toString())
// Requires friends:read + presence:read and an accepted friendship.
// Keep myUserId as the presence key even when friendUserId sorts first.
val track = JSONObject().put("topic", topic).put("event", "presence").put("ref", "2").put("join_ref", "1")
    .put("payload", JSONObject().put("type", "presence").put("event", "track")
        .put("payload", JSONObject().put("user_id", myUserId)))
// Send track only with presence:write, after the successful join.

const { items: friends } = await api("friends.list");
for (const friend of friends) {
  if (!Object.hasOwn(friend, "last_seen_at")) continue;
  const lastSeen = friend.last_seen_at ? new Date(friend.last_seen_at) : null;
  showLastSeen(friend.user_id, lastSeen);
}

val friends = api("friends.list").getJSONArray("items")
for (i in 0 until friends.length()) {
    val friend = friends.getJSONObject(i)
    if (!friend.has("last_seen_at")) continue
    val lastSeen = if (friend.isNull("last_seen_at")) null
        else java.time.OffsetDateTime.parse(friend.getString("last_seen_at")).toInstant()
    showLastSeen(friend.getString("user_id"), lastSeen)
}

const drawing = { version: 1, width: 800, height: 600,
  strokes: [{ pen: "pixel", color: "#222222", size: 4, points: [[10, 10], [40, 30]] }] };
const draft = { board_id: boardId, draft_id: crypto.randomUUID(), revision_id: crypto.randomUUID(),
  payload: { body: "Hello everyone!", drawing }, operation_id: crypto.randomUUID() };
const saved = await api("boards.save_draft", draft);
// Save the returned revision_id. Preserve both versions when saved.conflict is true.
// Only when the user presses Publish:
const pending = { board_id: boardId, body: draft.payload.body, drawing, operation_id: crypto.randomUUID() };
const published = await api("boards.publish", pending);
// Only when the user presses Yeah:
const reaction = { board_id: boardId, post_id: published.id, yeah: true, operation_id: crypto.randomUUID() };
await api("boards.react", reaction);

val drawing = JSONObject("""{"version":1,"width":800,"height":600,"strokes":[
  {"pen":"pixel","color":"#222222","size":4,"points":[[10,10],[40,30]]}]}""")
val draft = JSONObject().put("board_id", boardId)
    .put("draft_id", java.util.UUID.randomUUID().toString())
    .put("revision_id", java.util.UUID.randomUUID().toString())
    .put("payload", JSONObject().put("body", "Hello everyone!").put("drawing", drawing))
    .put("operation_id", java.util.UUID.randomUUID().toString())
val saved = api("boards.save_draft", draft)
// Preserve both versions when conflict is true. Publish only after the user's action:
val pending = JSONObject().put("board_id", boardId).put("body", "Hello everyone!").put("drawing", drawing)
    .put("operation_id", java.util.UUID.randomUUID().toString())
val published = api("boards.publish", pending)
val reaction = JSONObject().put("board_id", boardId).put("post_id", published.getString("id"))
    .put("yeah", true).put("operation_id", java.util.UUID.randomUUID().toString())
// Send only when the user presses Yeah:
api("boards.react", reaction)

const block = { user_id: selectedUserId, blocked: true, operation_id: crypto.randomUUID() };
await api("blocks.set", block); // Requires blocks:write.
const privacy = { block_messages: true, block_invites: true, operation_id: crypto.randomUUID() };
await api("privacy.set", privacy); // Requires privacy:write.

val block = JSONObject().put("user_id", selectedUserId).put("blocked", true)
    .put("operation_id", java.util.UUID.randomUUID().toString())
api("blocks.set", block) // Requires blocks:write.
val privacy = JSONObject().put("block_messages", true).put("block_invites", true)
    .put("operation_id", java.util.UUID.randomUUID().toString())
api("privacy.set", privacy) // Requires privacy:write.

// A short-lived avatar URL:
const signed = await requestJson("https://api.pocketpass.xyz/storage/v1/object/sign/avatars",
  { paths: [avatarPath], expiresIn: 300 });
// Render only the returned permitted URL; signed URLs expire.
// Upload the user's selected image (Blob/File):
const operationId = crypto.randomUUID(); // Persist once per send.
const path = `${myUserId}/${conversationId}/${operationId}.png`;
const upload = await fetch(`https://api.pocketpass.xyz/storage/v1/object/message-media/${path}`, {
  method: "POST", headers: { Authorization: `Bearer ${currentAccessToken}`, "Content-Type": "image/png" }, body: imageBlob
});
if (!upload.ok) {
  const failure = await upload.json().catch(() => ({}));
  const alreadyUploaded = upload.status === 409 || failure.statusCode === "409";
  if (!alreadyUploaded) throw new Error(`Upload failed: ${upload.status}`);
}
const pending = { conversation_id: conversationId, client_operation_id: operationId,
  attachment: { path, mime_type: "image/png" } };
await api("messages.send", pending);

// Encode each path segment, retaining slash separators.
val encodedAvatarPath = avatarPath.split("/").joinToString("/") { URLEncoder.encode(it, "UTF-8").replace("+", "%20") }
val signed = requestJson("https://api.pocketpass.xyz/storage/v1/object/sign/avatars/$encodedAvatarPath",
    JSONObject().put("expiresIn", 300).toString())
// Render the returned signed URL before it expires.
val operationId = java.util.UUID.randomUUID().toString()
val path = "$myUserId/$conversationId/$operationId.png"
val connection = URL("https://api.pocketpass.xyz/storage/v1/object/message-media/$path").openConnection() as HttpURLConnection
try {
    connection.requestMethod = "POST"; connection.doOutput = true
    connection.connectTimeout = 15000; connection.readTimeout = 30000
    connection.instanceFollowRedirects = false
    connection.setRequestProperty("Authorization", "Bearer $currentAccessToken")
    connection.setRequestProperty("Content-Type", "image/png")
    connection.outputStream.use { it.write(imageBytes) }
    val status = connection.responseCode
    val failure = if (status in 200..299) "" else connection.errorStream?.bufferedReader()?.use { it.readText() }.orEmpty()
    val alreadyUploaded = status == 409 ||
        runCatching { JSONObject(failure).optString("statusCode") == "409" }.getOrDefault(false)
    check(status in 200..299 || alreadyUploaded) { "Upload failed: $status" }
} finally { connection.disconnect() }
val pending = JSONObject().put("conversation_id", conversationId).put("client_operation_id", operationId)
    .put("attachment", JSONObject().put("path", path).put("mime_type", "image/png"))
api("messages.send", pending)

const form = new URLSearchParams({ grant_type: "authorization_code", code,
  redirect_uri: savedRedirectUri, code_verifier: savedVerifier });
// Node.js server; clientId and clientSecret come from server configuration.
const basic = Buffer.from(`${clientId}:${clientSecret}`, "utf8").toString("base64");
const response = await fetch("https://api.pocketpass.xyz/auth/v1/oauth/token", {
  method: "POST", headers: { Authorization: `Basic ${basic}`, "Content-Type": "application/x-www-form-urlencoded" }, body: form
});
if (!response.ok) throw new Error(`Token exchange failed: ${response.status}`);
const tokens = await response.json();
// Store tokens securely for this user; never log them.

// JVM server only. Use the shared form helper; restore savedVerifier after validating state.
val connection = URL("https://api.pocketpass.xyz/auth/v1/oauth/token").openConnection() as HttpURLConnection
val tokens = try {
    connection.requestMethod = "POST"; connection.doOutput = true
    connection.connectTimeout = 15000; connection.readTimeout = 30000
    connection.instanceFollowRedirects = false
    val basic = java.util.Base64.getEncoder().encodeToString("$clientId:$clientSecret".toByteArray(Charsets.UTF_8))
    connection.setRequestProperty("Authorization", "Basic $basic")
    connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
    val body = form(mapOf("grant_type" to "authorization_code", "code" to code,
        "redirect_uri" to savedRedirectUri, "code_verifier" to savedVerifier))
    connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
    check(connection.responseCode in 200..299) { "Token exchange failed: ${connection.responseCode}" }
    JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
} finally { connection.disconnect() }
// Store tokens securely for this user; never log them.

const socketUrl = `wss://api.pocketpass.xyz/realtime/v1/websocket?apikey=${encodeURIComponent(publishableKey)}&vsn=1.0.0`;
const join = { topic: `realtime:conversation:${conversationId}`, event: "phx_join", ref: "1", join_ref: "1",
  payload: { access_token: currentAccessToken, config: { private: true, broadcast: { self: false }, presence: { enabled: false } } } };
// websocket.send(JSON.stringify(join)) after the socket opens.
function onFrame(frame) {
  if (frame.event === "phx_reply" && frame.payload.status === "error") {
    showConnectionError(frame.payload.response); return;
  }
  if (frame.topic === join.topic && frame.event === "broadcast") scheduleMessageRefresh(conversationId);
}
const heartbeat = { topic: "phoenix", event: "heartbeat", payload: {}, ref: "2" };
// Send a heartbeat every 25 seconds with a NEW ref; reconnect if replies stop.
const refresh = { topic: join.topic, event: "access_token", payload: { access_token: currentAccessToken }, ref: "3", join_ref: "1" };
// Send after OAuth refresh on each joined channel. Never reuse these illustrative refs.

val socketUrl = "wss://api.pocketpass.xyz/realtime/v1/websocket?apikey=" +
    URLEncoder.encode(publishableKey, "UTF-8") + "&vsn=1.0.0"
val topic = "realtime:conversation:$conversationId"
val join = JSONObject().put("topic", topic).put("event", "phx_join").put("ref", "1").put("join_ref", "1")
    .put("payload", JSONObject().put("access_token", currentAccessToken).put("config", JSONObject()
        .put("private", true).put("broadcast", JSONObject().put("self", false))
        .put("presence", JSONObject().put("enabled", false))))
// websocket.send(join.toString()) after opening the socket.
fun onFrame(frame: JSONObject) {
    if (frame.optString("event") == "phx_reply" && frame.optJSONObject("payload")?.optString("status") == "error") {
        showConnectionError(frame.getJSONObject("payload")); return
    }
    if (frame.optString("topic") == topic && frame.optString("event") == "broadcast") scheduleMessageRefresh(conversationId)
}
val heartbeat = JSONObject().put("topic", "phoenix").put("event", "heartbeat").put("payload", JSONObject()).put("ref", "2")
// Send every 25 seconds with a NEW ref; reconnect if replies stop.
val refresh = JSONObject().put("topic", topic).put("event", "access_token").put("ref", "3").put("join_ref", "1")
    .put("payload", JSONObject().put("access_token", currentAccessToken))
// Send after OAuth refresh on every joined channel. Never reuse these illustrative refs.

const request = {};
const result = await api("session.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("session.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("session.revoke", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("session.revoke", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("me.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("me.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "user_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("profiles.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "user_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("profiles.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "user_ids": [
    "97000000-0000-4000-8000-000000000001"
  ]
};
const result = await api("profiles.get_many", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "user_ids": [
    "97000000-0000-4000-8000-000000000001"
  ]
}
""")
val result = api("profiles.get_many", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("friends.list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("friends.list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("friends.requests_list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("friends.requests_list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("friends.request_send", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("friends.request_send", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "request_id": "97000000-0000-4000-8000-000000000001",
  "accept": true,
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("friends.request_respond", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "request_id": "97000000-0000-4000-8000-000000000001",
  "accept": true,
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("friends.request_respond", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "request_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("friends.request_cancel", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "request_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("friends.request_cancel", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("friends.remove", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("friends.remove", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("friends.code_get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("friends.code_get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "code": "12345678"
};
const result = await api("friends.code_resolve", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "code": "12345678"
}
""")
val result = api("friends.code_resolve", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("conversations.list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("conversations.list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("conversations.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("conversations.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("conversations.open", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("conversations.open", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "title": "Friends",
  "member_ids": [
    "97000000-0000-4000-8000-000000000001"
  ],
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("conversations.create", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "title": "Friends",
  "member_ids": [
    "97000000-0000-4000-8000-000000000001"
  ],
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("conversations.create", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "member_ids": [
    "97000000-0000-4000-8000-000000000001"
  ],
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("conversations.add_members", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "member_ids": [
    "97000000-0000-4000-8000-000000000001"
  ],
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("conversations.add_members", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("conversations.remove_member", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("conversations.remove_member", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("conversations.leave", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("conversations.leave", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "title": "Friends",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("conversations.rename", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "title": "Friends",
  "client_operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("conversations.rename", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("conversations.mark_read", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("conversations.mark_read", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("messages.list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("messages.list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello!"
};
// Generate once per user action; persist request before sending.
request.client_operation_id = crypto.randomUUID();
const result = await api("messages.send", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "conversation_id": "97000000-0000-4000-8000-000000000001",
  "client_operation_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello!"
}
""")
// Generate once per user action; persist request before sending.
request.put("client_operation_id", java.util.UUID.randomUUID().toString())
val result = api("messages.send", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "message_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello everyone!"
};
const result = await api("messages.edit", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "message_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello everyone!"
}
""")
val result = api("messages.edit", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "message_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("messages.delete", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "message_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("messages.delete", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("notifications.list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("notifications.list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "notification_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("notifications.mark_read", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "notification_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("notifications.mark_read", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "notification_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("notifications.delete", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "notification_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("notifications.delete", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("tokens.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("tokens.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("encounters.list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("encounters.list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("puzzles.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("puzzles.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "user_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("piips.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "user_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("piips.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("blocks.list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("blocks.list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "user_id": "97000000-0000-4000-8000-000000000001",
  "blocked": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("blocks.set", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "user_id": "97000000-0000-4000-8000-000000000001",
  "blocked": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("blocks.set", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("privacy.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("privacy.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "block_messages": true,
  "block_invites": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("privacy.set", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "block_messages": true,
  "block_invites": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("privacy.set", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("boards.settings", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("boards.settings", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "scope": "explore",
  "limit": 30
};
const result = await api("boards.list", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "scope": "explore",
  "limit": 30
}
""")
val result = api("boards.list", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.get", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.get", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "sort": "newest",
  "limit": 30
};
const result = await api("boards.feed", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "sort": "newest",
  "limit": 30
}
""")
val result = api("boards.feed", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "post_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.replies", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "post_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.replies", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "post_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.post", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "post_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.post", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "post_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.preview", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "post_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.preview", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "asset_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.asset", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "asset_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.asset", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon"
};
const result = await api("boards.branding_preview", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon"
}
""")
val result = api("boards.branding_preview", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("boards.drafts", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("boards.drafts", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("boards.inbox", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("boards.inbox", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("boards.invitations", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("boards.invitations", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("boards.proposals", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("boards.proposals", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("boards.notices", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("boards.notices", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.members", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.members", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.management", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.management", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.outgoing_invitations", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.outgoing_invitations", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001"
};
const result = await api("boards.history", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001"
}
""")
val result = api("boards.history", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {};
const result = await api("boards.stationery", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{}
""")
val result = api("boards.stationery", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "name": "Handheld chat",
  "visibility": "public",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.propose", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "name": "Handheld chat",
  "visibility": "public",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.propose", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.join", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.join", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.accept_invitation", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.accept_invitation", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "code": "REPLACE_WITH_INVITATION_CODE",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.join_code", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "code": "REPLACE_WITH_INVITATION_CODE",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.join_code", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.decline_invitation", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.decline_invitation", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "approve": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.decide_join", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "approve": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.decide_join", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.invite", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.invite", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.create_code", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.create_code", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.revoke_invitation", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.revoke_invitation", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.leave", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.leave", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "muted": true
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.preferences", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "muted": true
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.preferences", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "enabled": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.push_preference", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "enabled": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.push_preference", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "description": "A place to share handheld games."
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.update_board", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "description": "A place to share handheld games."
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.update_board", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "archived": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.archive", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "archived": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.archive", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.transfer", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.transfer", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "moderator": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.set_moderator", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "moderator": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.set_moderator", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.accept_transfer", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.accept_transfer", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello everyone!"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.publish", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello everyone!"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.publish", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello everyone!",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.edit", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "body": "Hello everyone!",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.edit", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.delete_post", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.delete_post", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "spoiler": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.spoiler", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "spoiler": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.spoiler", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "yeah": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.react", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "post_id": "97000000-0000-4000-8000-000000000001",
  "yeah": true,
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.react", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon",
  "drawing": {
    "version": 1,
    "width": 800,
    "height": 600,
    "strokes": [
      {
        "pen": "pixel",
        "color": "#222222",
        "size": 4,
        "points": [
          [
            10,
            10
          ],
          [
            40,
            30
          ]
        ]
      }
    ]
  },
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.draw_branding", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon",
  "drawing": {
    "version": 1,
    "width": 800,
    "height": 600,
    "strokes": [
      {
        "pen": "pixel",
        "color": "#222222",
        "size": 4,
        "points": [
          [
            10,
            10
          ],
          [
            40,
            30
          ]
        ]
      }
    ]
  },
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.draw_branding", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "draft_id": "97000000-0000-4000-8000-000000000001",
  "revision_id": "97000000-0000-4000-8000-000000000001",
  "payload": {
    "body": "My unfinished note"
  },
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.save_draft", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "draft_id": "97000000-0000-4000-8000-000000000001",
  "revision_id": "97000000-0000-4000-8000-000000000001",
  "payload": {
    "body": "My unfinished note"
  },
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.save_draft", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "revision_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.discard_draft", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "revision_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.discard_draft", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.report", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.report", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.resolve_report", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.resolve_report", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "kind": "mute",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.restrict", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "user_id": "97000000-0000-4000-8000-000000000001",
  "kind": "mute",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.restrict", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.revoke_restriction", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.revoke_restriction", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "case_id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.appeal", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "case_id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.appeal", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.resolve_appeal", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "id": "97000000-0000-4000-8000-000000000001",
  "reason": "Explain the reason for this action.",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.resolve_appeal", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.read_event", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.read_event", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.read_thread", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.read_thread", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "stationery_id": "plain",
  "operation_id": "97000000-0000-4000-8000-000000000001"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.buy_stationery", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "stationery_id": "plain",
  "operation_id": "97000000-0000-4000-8000-000000000001"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.buy_stationery", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "image": "REPLACE_WITH_BASE64_IMAGE_BYTES"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.artwork_upload", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "image": "REPLACE_WITH_BASE64_IMAGE_BYTES"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.artwork_upload", request)
// Render result in your app; handle ApiError without discarding pending work.

const request = {
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "source_hash": "REPLACE_WITH_LOWERCASE_SHA256"
};
// Generate once per user action; persist request before sending.
request.operation_id = crypto.randomUUID();
const result = await api("boards.prepare_branding", request);
// Render result in your app; handle ApiError without discarding pending work.

val request = JSONObject("""
{
  "board_id": "97000000-0000-4000-8000-000000000001",
  "kind": "icon",
  "operation_id": "97000000-0000-4000-8000-000000000001",
  "source_hash": "REPLACE_WITH_LOWERCASE_SHA256"
}
""")
// Generate once per user action; persist request before sending.
request.put("operation_id", java.util.UUID.randomUUID().toString())
val result = api("boards.prepare_branding", request)
// Render result in your app; handle ApiError without discarding pending work.