@roundtable-bb/sdk 0.1.6 → 0.1.9

package/src/generated/client.ts

@@ -1,291 +1,403 @@
 // AUTO-GENERATED — do not edit manually.
 // Run `nx run @roundtable-bb/sdk:codegen` to regenerate.
 
-import type { ApiKey, Category, CreateApiKey, CreateCategory, CreateGroup, CreatePost, CreateThread, CreatedApiKey, GrantPlatformOwner, Group, Id, Notification, PaginatedResponse, PlatformSetting, Post, ReorderCategory, SearchResponse, SearchResultType, SetGroupCategories, SetGroupPermissions, SetThreadReadStatus, SetUserGroups, TenantToken, Thread, ThreadReadStatus, UpdateCategory, UpdateGroup, UpdatePlatformSetting, UpdateThread, UpdateUserProfile, UserMembership, UserProfile } from '@roundtable-bb/types'
+import type { Category, CreateApiKey, CreateCategory, CreateGroup, CreatePost, CreateTenant, CreateThread, GrantPlatformOwner, Group, GroupMember, Id, Notification, OwnedTenant, PaginatedResponse, PlatformSetting, Post, ReorderCategory, SearchResponse, SearchResultType, SetCustomDomain, SetGroupCategories, SetGroupPermissions, SetThreadReadStatus, SetUserGroups, Tenant, TenantToken, Thread, ThreadReadStatus, UpdateCategory, UpdateGroup, UpdatePlatformSetting, UpdateThread, UpdateUserProfile, UserMembership, UserProfile } from '@roundtable-bb/types'
 import { request, type RoundtableClientOpts } from '../request.js'
 
-export class RoundtableClient {
+export class AcpClient {
   constructor(private readonly opts: RoundtableClientOpts) {}
 
   /** Export a signed tenant backup (platform owners only) */
-  backupTenant(params: { id: string }, query?: { includeContent?: boolean }): Promise<unknown> {
-    return request(this.opts, 'GET', `/tenants/${params.id}/backup`, { query, useCredentials: true })
+  backupTenant(params: { tenantId: string }, query?: { includeContent?: boolean }): Promise<unknown> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/backup`, { query, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Count read and unread notifications */
   countNotifications(): Promise<unknown> {
-    return request(this.opts, 'GET', '/notifications/count', { useCredentials: true })
+    return request(this.opts, 'GET', '/api/notifications/count', { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
   }
 
   /** Create a platform-scoped API key (returned once in full) */
-  createApiKey(body: CreateApiKey): Promise<CreatedApiKey> {
-    return request(this.opts, 'POST', '/platform/api-keys', { body, useCredentials: true })
+  createApiKey(body: CreateApiKey): Promise<unknown> {
+    return request(this.opts, 'POST', '/api/platform/api-keys', { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Create a category (requires category.create permission) */
-  createCategory(body: CreateCategory): Promise<Category> {
-    return request(this.opts, 'POST', '/categories', { body, useCredentials: true })
+  createCategory(params: { tenantId: string }, body: CreateCategory): Promise<Category> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/categories`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Create a group (requires group.create permission) */
-  createGroup(body: CreateGroup): Promise<Group> {
-    return request(this.opts, 'POST', '/groups', { body, useCredentials: true })
+  createGroup(params: { tenantId: string }, body: CreateGroup): Promise<Group> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/groups`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Create a post in a thread */
-  createPost(params: { threadId: string }, body: CreatePost): Promise<Post> {
-    if (!this.opts.token) throw new Error('createPost requires a token (API key or JWT)')
-    return request(this.opts, 'POST', `/threads/${params.threadId}/posts`, { body })
+  createPost(params: { tenantId: string; threadId: string }, body: CreatePost): Promise<Post> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/threads/${params.threadId}/posts`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Create a new tenant (requires allow_tenant_creation platform setting or platform owner) */
-  createTenant(body: unknown): Promise<unknown> {
-    return request(this.opts, 'POST', '/tenants', { body, useCredentials: true })
+  createTenant(body: CreateTenant): Promise<Tenant> {
+    return request(this.opts, 'POST', '/api/tenants', { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Create a thread (and its first post) */
-  createThread(params: { categoryId: string }, body: CreateThread): Promise<Thread> {
-    if (!this.opts.token) throw new Error('createThread requires a token (API key or JWT)')
-    return request(this.opts, 'POST', `/categories/${params.categoryId}/threads`, { body })
+  createThread(params: { tenantId: string; categoryId: string }, body: CreateThread): Promise<Thread> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/categories/${params.categoryId}/threads`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Delete a platform-scoped API key */
-  deleteApiKey(params: { id: string }): Promise<void> {
-    return request(this.opts, 'DELETE', `/platform/api-keys/${params.id}`, { useCredentials: true })
+  deleteApiKey(params: { keyId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/platform/api-keys/${params.keyId}`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Delete a category (requires category.delete permission) */
-  deleteCategory(params: { id: string }): Promise<void> {
-    return request(this.opts, 'DELETE', `/categories/${params.id}`, { useCredentials: true })
+  deleteCategory(params: { tenantId: string; categoryId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/categories/${params.categoryId}`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Delete a group (requires group.delete permission) */
-  deleteGroup(params: { id: string }): Promise<void> {
-    return request(this.opts, 'DELETE', `/groups/${params.id}`, { useCredentials: true })
+  deleteGroup(params: { tenantId: string; groupId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/groups/${params.groupId}`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Delete a notification */
-  deleteNotification(params: { id: string }): Promise<void> {
-    return request(this.opts, 'DELETE', `/notifications/${params.id}`, { useCredentials: true })
+  deleteNotification(params: { notificationId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/notifications/${params.notificationId}`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Soft-delete a post */
-  deletePost(params: { id: string }): Promise<void> {
-    if (!this.opts.token) throw new Error('deletePost requires a token (API key or JWT)')
-    return request(this.opts, 'DELETE', `/posts/${params.id}`)
+  deletePost(params: { tenantId: string; postId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/posts/${params.postId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Delete a thread */
-  deleteThread(params: { id: string }): Promise<void> {
-    if (!this.opts.token) throw new Error('deleteThread requires a token (API key or JWT)')
-    return request(this.opts, 'DELETE', `/threads/${params.id}`)
+  deleteThread(params: { tenantId: string; threadId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/threads/${params.threadId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Exchange session cookie for a short-lived tenant JWT */
   exchangeTenantToken(): Promise<TenantToken> {
-    return request(this.opts, 'POST', '/tenant-token', { useCredentials: true })
+    return request(this.opts, 'POST', '/api/tenant-token', { routeAuth: { acceptsBetterAuth: true } })
   }
 
   /** Get a single category */
-  getCategory(params: { id: string }): Promise<Category> {
-    if (!this.opts.token) throw new Error('getCategory requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/categories/${params.id}`)
+  getCategory(params: { tenantId: string; categoryId: string }): Promise<Category> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/categories/${params.categoryId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Get a group */
-  getGroup(params: { id: string }): Promise<Group> {
-    if (!this.opts.token) throw new Error('getGroup requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/groups/${params.id}`)
+  getGroup(params: { tenantId: string; groupId: string }): Promise<Group> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/groups/${params.groupId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Get own profile */
   getMe(): Promise<UserProfile> {
-    if (!this.opts.token) throw new Error('getMe requires a token (API key or JWT)')
-    return request(this.opts, 'GET', '/users/me')
+    return request(this.opts, 'GET', '/api/users/me', { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
   }
 
   /** Get the current owner of a tenant */
-  getTenantOwner(params: { id: string }): Promise<unknown> {
-    return request(this.opts, 'GET', `/tenants/${params.id}/owner`, { useCredentials: true })
+  getTenantOwner(params: { tenantId: string }): Promise<unknown> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/owner`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Get a single thread */
-  getThread(params: { id: string }): Promise<Thread> {
-    if (!this.opts.token) throw new Error('getThread requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/threads/${params.id}`)
+  getThread(params: { tenantId: string; threadId: string }): Promise<Thread> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/threads/${params.threadId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Get read status for the current user in a thread */
-  getThreadReadStatus(params: { id: string }): Promise<ThreadReadStatus> {
-    if (!this.opts.token) throw new Error('getThreadReadStatus requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/threads/${params.id}/read-status`)
+  getThreadReadStatus(params: { tenantId: string; threadId: string }): Promise<ThreadReadStatus> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/threads/${params.threadId}/read-status`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Get a user profile by ID */
-  getUser(params: { id: string }): Promise<UserProfile> {
-    if (!this.opts.token) throw new Error('getUser requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/users/${params.id}`)
+  getUser(params: { userId: string }): Promise<UserProfile> {
+    return request(this.opts, 'GET', `/api/users/${params.userId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Get user group memberships in the current tenant */
-  getUserMembership(params: { id: string }): Promise<UserMembership> {
-    if (!this.opts.token) throw new Error('getUserMembership requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/users/${params.id}/membership`)
+  getUserMembership(params: { tenantId: string; userId: string }): Promise<UserMembership> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/users/${params.userId}/membership`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Grant platform owner status to a user (platform owners only) */
   grantPlatformOwner(body: GrantPlatformOwner): Promise<void> {
-    return request(this.opts, 'POST', '/platform/owners', { body, useCredentials: true })
+    return request(this.opts, 'POST', '/api/platform/owners', { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** List your platform-scoped API keys */
-  listApiKeys(): Promise<ApiKey[]> {
-    return request(this.opts, 'GET', '/platform/api-keys', { useCredentials: true })
+  listApiKeys(): Promise<unknown> {
+    return request(this.opts, 'GET', '/api/platform/api-keys', { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** List visible categories for the requesting user */
-  listCategories(): Promise<Category[]> {
-    if (!this.opts.token) throw new Error('listCategories requires a token (API key or JWT)')
-    return request(this.opts, 'GET', '/categories')
+  listCategories(params: { tenantId: string }): Promise<Category[]> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/categories`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
+  }
+
+  /** List members of a group */
+  listGroupMembers(params: { tenantId: string; groupId: string }): Promise<GroupMember[]> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/groups/${params.groupId}/members`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
   }
 
   /** List groups */
-  listGroups(): Promise<Group[]> {
-    if (!this.opts.token) throw new Error('listGroups requires a token (API key or JWT)')
-    return request(this.opts, 'GET', '/groups')
+  listGroups(params: { tenantId: string }): Promise<Group[]> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/groups`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
   }
 
   /** Get unified notification inbox */
   listNotifications(query?: { cursor?: Id; limit?: number; unreadOnly?: boolean }): Promise<PaginatedResponse<Notification>> {
-    return request(this.opts, 'GET', '/notifications', { query, useCredentials: true })
+    return request(this.opts, 'GET', '/api/notifications', { query, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** List platform owner user IDs (platform owners only) */
   listPlatformOwners(): Promise<string[]> {
-    return request(this.opts, 'GET', '/platform/owners', { useCredentials: true })
+    return request(this.opts, 'GET', '/api/platform/owners', { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** List all platform settings (platform owners only) */
   listPlatformSettings(): Promise<PlatformSetting[]> {
-    return request(this.opts, 'GET', '/platform/settings', { useCredentials: true })
+    return request(this.opts, 'GET', '/api/platform/settings', { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** List posts in a thread — cursor pagination or anchor via ?from=postId */
-  listPosts(params: { threadId: string }, query?: { cursor?: Id; limit?: number; from?: Id }): Promise<PaginatedResponse<Post>> {
-    if (!this.opts.token) throw new Error('listPosts requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/threads/${params.threadId}/posts`, { query })
+  listPosts(params: { tenantId: string; threadId: string }, query?: { cursor?: Id; limit?: number; from?: Id }): Promise<PaginatedResponse<Post>> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/threads/${params.threadId}/posts`, { query, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** List tenants owned by the current user (platform owners see all) */
+  listTenants(query?: { search?: string }): Promise<OwnedTenant[]> {
+    return request(this.opts, 'GET', '/api/tenants', { query, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** List threads in a category */
-  listThreads(params: { categoryId: string }, query?: { cursor?: Id; limit?: number }): Promise<PaginatedResponse<Thread>> {
-    if (!this.opts.token) throw new Error('listThreads requires a token (API key or JWT)')
-    return request(this.opts, 'GET', `/categories/${params.categoryId}/threads`, { query })
+  listThreads(params: { tenantId: string; categoryId: string }, query?: { cursor?: Id; limit?: number }): Promise<PaginatedResponse<Thread>> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/categories/${params.categoryId}/threads`, { query, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Mark a notification as read */
-  markNotificationRead(params: { id: string }): Promise<Notification> {
-    return request(this.opts, 'PATCH', `/notifications/${params.id}/read`, { useCredentials: true })
+  markNotificationRead(params: { notificationId: string }): Promise<Notification> {
+    return request(this.opts, 'PATCH', `/api/notifications/${params.notificationId}/read`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Set the position of each category (requires category.edit permission) */
-  reorderCategories(body: ReorderCategory): Promise<void> {
-    return request(this.opts, 'PUT', '/categories/reorder', { body, useCredentials: true })
+  reorderCategories(params: { tenantId: string }, body: ReorderCategory): Promise<void> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/categories/reorder`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Set the position of each group (requires group.edit permission) */
-  reorderGroups(body: ReorderCategory): Promise<void> {
-    return request(this.opts, 'PUT', '/groups/reorder', { body, useCredentials: true })
+  reorderGroups(params: { tenantId: string }, body: ReorderCategory): Promise<void> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/groups/reorder`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Restore a tenant from a signed backup (platform owners only) */
-  restoreTenant(params: { id: string }, body: unknown): Promise<unknown> {
-    return request(this.opts, 'POST', `/tenants/${params.id}/restore`, { body, useCredentials: true })
+  restoreTenant(params: { tenantId: string }, body: unknown): Promise<unknown> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/restore`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Revoke platform owner status from a user (platform owners only) */
   revokePlatformOwner(params: { userId: string }): Promise<void> {
-    return request(this.opts, 'DELETE', `/platform/owners/${params.userId}`, { useCredentials: true })
+    return request(this.opts, 'DELETE', `/api/platform/owners/${params.userId}`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Full-text search across threads and posts (visible categories only) */
-  search(query?: { q: string; type?: SearchResultType; categoryId?: Id; limit?: number }): Promise<SearchResponse> {
-    if (!this.opts.token) throw new Error('search requires a token (API key or JWT)')
-    return request(this.opts, 'GET', '/search', { query })
+  search(params: { tenantId: string }, query?: { q: string; type?: SearchResultType; categoryId?: Id; limit?: number }): Promise<SearchResponse> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/search`, { query, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Set category visibility for a group (requires group.edit permission) */
-  setGroupCategories(params: { id: string }, body: SetGroupCategories): Promise<Group> {
-    if (!this.opts.token) throw new Error('setGroupCategories requires a token (API key or JWT)')
-    return request(this.opts, 'PUT', `/groups/${params.id}/categories`, { body })
+  setGroupCategories(params: { tenantId: string; groupId: string }, body: SetGroupCategories): Promise<Group> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/groups/${params.groupId}/categories`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Replace all permissions for a group (requires group.edit permission) */
-  setGroupPermissions(params: { id: string }, body: SetGroupPermissions): Promise<Group> {
-    if (!this.opts.token) throw new Error('setGroupPermissions requires a token (API key or JWT)')
-    return request(this.opts, 'PUT', `/groups/${params.id}/permissions`, { body })
+  setGroupPermissions(params: { tenantId: string; groupId: string }, body: SetGroupPermissions): Promise<Group> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/groups/${params.groupId}/permissions`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
+  }
+
+  /** Set or remove the custom domain for a tenant */
+  setTenantCustomDomain(params: { tenantId: string }, body: SetCustomDomain): Promise<void> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/custom-domain`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Mark a thread as read up to a given post */
-  setThreadReadStatus(params: { id: string }, body: SetThreadReadStatus): Promise<void> {
-    if (!this.opts.token) throw new Error('setThreadReadStatus requires a token (API key or JWT)')
-    return request(this.opts, 'PUT', `/threads/${params.id}/read-status`, { body })
+  setThreadReadStatus(params: { tenantId: string; threadId: string }, body: SetThreadReadStatus): Promise<void> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/threads/${params.threadId}/read-status`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Replace user group assignments in the current tenant (requires group.assign permission) */
-  setUserGroups(params: { id: string }, body: SetUserGroups): Promise<UserMembership> {
-    if (!this.opts.token) throw new Error('setUserGroups requires a token (API key or JWT)')
-    return request(this.opts, 'PUT', `/users/${params.id}/membership`, { body })
+  setUserGroups(params: { tenantId: string; userId: string }, body: SetUserGroups): Promise<UserMembership> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/users/${params.userId}/membership`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Subscribe to a thread */
-  subscribeThread(params: { id: string }): Promise<void> {
-    if (!this.opts.token) throw new Error('subscribeThread requires a token (API key or JWT)')
-    return request(this.opts, 'POST', `/threads/${params.id}/subscribe`)
+  subscribeThread(params: { tenantId: string; threadId: string }): Promise<void> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/threads/${params.threadId}/subscribe`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Transfer tenant ownership to another existing user (only the current owner can do this) */
-  transferTenantOwner(params: { id: string }, body: GrantPlatformOwner): Promise<void> {
-    return request(this.opts, 'PUT', `/tenants/${params.id}/owner`, { body, useCredentials: true })
+  transferTenantOwner(params: { tenantId: string }, body: GrantPlatformOwner): Promise<void> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/owner`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Unsubscribe from a thread */
-  unsubscribeThread(params: { id: string }): Promise<void> {
-    if (!this.opts.token) throw new Error('unsubscribeThread requires a token (API key or JWT)')
-    return request(this.opts, 'DELETE', `/threads/${params.id}/subscribe`)
+  unsubscribeThread(params: { tenantId: string; threadId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/threads/${params.threadId}/subscribe`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Update a category (requires category.edit permission) */
-  updateCategory(params: { id: string }, body: UpdateCategory): Promise<Category> {
-    if (!this.opts.token) throw new Error('updateCategory requires a token (API key or JWT)')
-    return request(this.opts, 'PATCH', `/categories/${params.id}`, { body })
+  updateCategory(params: { tenantId: string; categoryId: string }, body: UpdateCategory): Promise<Category> {
+    return request(this.opts, 'PATCH', `/api/tenants/${params.tenantId}/categories/${params.categoryId}`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Update a group (requires group.edit permission) */
-  updateGroup(params: { id: string }, body: UpdateGroup): Promise<Group> {
-    if (!this.opts.token) throw new Error('updateGroup requires a token (API key or JWT)')
-    return request(this.opts, 'PATCH', `/groups/${params.id}`, { body })
+  updateGroup(params: { tenantId: string; groupId: string }, body: UpdateGroup): Promise<Group> {
+    return request(this.opts, 'PATCH', `/api/tenants/${params.tenantId}/groups/${params.groupId}`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Update own profile */
   updateMe(body: UpdateUserProfile): Promise<UserProfile> {
-    if (!this.opts.token) throw new Error('updateMe requires a token (API key or JWT)')
-    return request(this.opts, 'PATCH', '/users/me', { body })
+    return request(this.opts, 'PATCH', '/api/users/me', { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
   }
 
   /** Update a platform setting (platform owners only) */
   updatePlatformSetting(params: { key: string }, body: UpdatePlatformSetting): Promise<PlatformSetting> {
-    return request(this.opts, 'PATCH', `/platform/settings/${params.key}`, { body, useCredentials: true })
+    return request(this.opts, 'PATCH', `/api/platform/settings/${params.key}`, { body, routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true } })
+  }
+
+  /** Edit a post (author or post.edit permission) */
+  updatePost(params: { tenantId: string; postId: string }, body: CreatePost): Promise<Post> {
+    return request(this.opts, 'PATCH', `/api/tenants/${params.tenantId}/posts/${params.postId}`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Update a thread (title, pin, lock, move) */
+  updateThread(params: { tenantId: string; threadId: string }, body: UpdateThread): Promise<Thread> {
+    return request(this.opts, 'PATCH', `/api/tenants/${params.tenantId}/threads/${params.threadId}`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+}
+
+export class TenantClient {
+  constructor(private readonly opts: RoundtableClientOpts) {}
+
+  /** Count read and unread notifications */
+  countNotifications(): Promise<unknown> {
+    return request(this.opts, 'GET', '/api/notifications/count', { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
+  }
+
+  /** Create a post in a thread */
+  createPost(params: { tenantId: string; threadId: string }, body: CreatePost): Promise<Post> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/threads/${params.threadId}/posts`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Create a thread (and its first post) */
+  createThread(params: { tenantId: string; categoryId: string }, body: CreateThread): Promise<Thread> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/categories/${params.categoryId}/threads`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Soft-delete a post */
+  deletePost(params: { tenantId: string; postId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/posts/${params.postId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Delete a thread */
+  deleteThread(params: { tenantId: string; threadId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/threads/${params.threadId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Exchange session cookie for a short-lived tenant JWT */
+  exchangeTenantToken(): Promise<TenantToken> {
+    return request(this.opts, 'POST', '/api/tenant-token', { routeAuth: { acceptsBetterAuth: true, tenantUseCredentials: true } })
+  }
+
+  /** Get a single category */
+  getCategory(params: { tenantId: string; categoryId: string }): Promise<Category> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/categories/${params.categoryId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Get a group */
+  getGroup(params: { tenantId: string; groupId: string }): Promise<Group> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/groups/${params.groupId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Get own profile */
+  getMe(): Promise<UserProfile> {
+    return request(this.opts, 'GET', '/api/users/me', { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
+  }
+
+  /** Get a single thread */
+  getThread(params: { tenantId: string; threadId: string }): Promise<Thread> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/threads/${params.threadId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Get read status for the current user in a thread */
+  getThreadReadStatus(params: { tenantId: string; threadId: string }): Promise<ThreadReadStatus> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/threads/${params.threadId}/read-status`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Get a user profile by ID */
+  getUser(params: { userId: string }): Promise<UserProfile> {
+    return request(this.opts, 'GET', `/api/users/${params.userId}`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Get user group memberships in the current tenant */
+  getUserMembership(params: { tenantId: string; userId: string }): Promise<UserMembership> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/users/${params.userId}/membership`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** List visible categories for the requesting user */
+  listCategories(params: { tenantId: string }): Promise<Category[]> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/categories`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
+  }
+
+  /** List members of a group */
+  listGroupMembers(params: { tenantId: string; groupId: string }): Promise<GroupMember[]> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/groups/${params.groupId}/members`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
+  }
+
+  /** List groups */
+  listGroups(params: { tenantId: string }): Promise<Group[]> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/groups`, { routeAuth: { acceptsApiKey: true, acceptsBetterAuth: true, acceptsTenantJwt: true } })
+  }
+
+  /** List posts in a thread — cursor pagination or anchor via ?from=postId */
+  listPosts(params: { tenantId: string; threadId: string }, query?: { cursor?: Id; limit?: number; from?: Id }): Promise<PaginatedResponse<Post>> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/threads/${params.threadId}/posts`, { query, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** List threads in a category */
+  listThreads(params: { tenantId: string; categoryId: string }, query?: { cursor?: Id; limit?: number }): Promise<PaginatedResponse<Thread>> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/categories/${params.categoryId}/threads`, { query, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Full-text search across threads and posts (visible categories only) */
+  search(params: { tenantId: string }, query?: { q: string; type?: SearchResultType; categoryId?: Id; limit?: number }): Promise<SearchResponse> {
+    return request(this.opts, 'GET', `/api/tenants/${params.tenantId}/search`, { query, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Mark a thread as read up to a given post */
+  setThreadReadStatus(params: { tenantId: string; threadId: string }, body: SetThreadReadStatus): Promise<void> {
+    return request(this.opts, 'PUT', `/api/tenants/${params.tenantId}/threads/${params.threadId}/read-status`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Subscribe to a thread */
+  subscribeThread(params: { tenantId: string; threadId: string }): Promise<void> {
+    return request(this.opts, 'POST', `/api/tenants/${params.tenantId}/threads/${params.threadId}/subscribe`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
+  }
+
+  /** Unsubscribe from a thread */
+  unsubscribeThread(params: { tenantId: string; threadId: string }): Promise<void> {
+    return request(this.opts, 'DELETE', `/api/tenants/${params.tenantId}/threads/${params.threadId}/subscribe`, { routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Edit a post (author or post.edit permission) */
-  updatePost(params: { id: string }, body: CreatePost): Promise<Post> {
-    if (!this.opts.token) throw new Error('updatePost requires a token (API key or JWT)')
-    return request(this.opts, 'PATCH', `/posts/${params.id}`, { body })
+  updatePost(params: { tenantId: string; postId: string }, body: CreatePost): Promise<Post> {
+    return request(this.opts, 'PATCH', `/api/tenants/${params.tenantId}/posts/${params.postId}`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 
   /** Update a thread (title, pin, lock, move) */
-  updateThread(params: { id: string }, body: UpdateThread): Promise<Thread> {
-    if (!this.opts.token) throw new Error('updateThread requires a token (API key or JWT)')
-    return request(this.opts, 'PATCH', `/threads/${params.id}`, { body })
+  updateThread(params: { tenantId: string; threadId: string }, body: UpdateThread): Promise<Thread> {
+    return request(this.opts, 'PATCH', `/api/tenants/${params.tenantId}/threads/${params.threadId}`, { body, routeAuth: { acceptsApiKey: true, acceptsTenantJwt: true } })
   }
 }

package/src/index.ts

@@ -1,3 +1,3 @@
-export { RoundtableClient } from './generated/client.js'
+export { AcpClient, TenantClient } from './generated/client.js'
 export type { RoundtableClientOpts } from './request.js'
 export type * from '@roundtable-bb/types'

package/src/request.ts

@@ -3,12 +3,45 @@ export interface RoundtableClientOpts {
   token?: string
 }
 
+interface RouteAuth {
+  acceptsApiKey?: boolean
+  acceptsBetterAuth?: boolean
+  acceptsTenantJwt?: boolean
+  requiresToken?: boolean
+  tenantUseCredentials?: boolean
+}
+
 export async function request<T>(
   opts: RoundtableClientOpts,
   method: string,
   path: string,
-  options?: { body?: unknown; query?: Record<string, unknown>; useCredentials?: boolean },
+  options?: {
+    body?: unknown
+    query?: Record<string, unknown>
+    useCredentials?: boolean
+    routeAuth?: RouteAuth
+  },
 ): Promise<T> {
+  const routeAuth = options?.routeAuth
+  let useCredentials = options?.useCredentials ?? false
+
+  // Decide auth strategy
+  if (routeAuth) {
+    // TenantClient: use credentials if explicitly required by route
+    if (routeAuth.tenantUseCredentials) {
+      useCredentials = true
+    }
+    // If token is available, use it (prefer token over credentials)
+    else if (opts.token && routeAuth.acceptsApiKey) {
+      useCredentials = false
+    }
+    // If no token but route accepts better-auth: use credentials
+    else if (!opts.token && routeAuth.acceptsBetterAuth) {
+      useCredentials = true
+    }
+    // Otherwise: make request without auth (backend will respond 401/403 if needed)
+  }
+
   const url = new URL(`${opts.baseUrl}${path}`)
   if (options?.query) {
     for (const [k, v] of Object.entries(options.query)) {
@@ -18,10 +51,10 @@ export async function request<T>(
 
   const res = await fetch(url.toString(), {
     method,
-    credentials: options?.useCredentials ? 'include' : undefined,
+    credentials: useCredentials ? 'include' : undefined,
     headers: {
       ...(options?.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
-      ...(opts.token ? { Authorization: `Bearer ${opts.token}` } : {}),
+      ...(opts.token && !useCredentials ? { Authorization: `Bearer ${opts.token}` } : {}),
     },
     body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
   })