@nvisy/sdk 0.50.0 → 0.51.0

package/dist/{services-DUixyxF2.js → services-CFFmQDgA.js}

@@ -37,28 +37,28 @@ var Account = class {
 		await this.#api.DELETE("/account/");
 	}
 	/**
-	* Get a public account profile by username
-	* @param username - Account username
+	* Get a public account profile by account id
+	* @param accountId - Account id
 	* @returns Promise that resolves with the public account details
 	* @throws {ApiError} if the request fails
 	*/
-	async getPublicAccount(username) {
-		const { data } = await this.#api.GET("/accounts/{username}/", { params: { path: { username } } });
+	async getPublicAccount(accountId) {
+		const { data } = await this.#api.GET("/accounts/{accountId}/", { params: { path: { accountId } } });
 		return data;
 	}
 	/**
 	* Upload an account's avatar image
-	* @param username - Account username
+	* @param accountId - Account id
 	* @param avatar - Avatar image to upload
 	* @returns Promise that resolves with the updated account
 	* @throws {ApiError} if the request fails
 	*/
-	async uploadAvatar(username, avatar) {
+	async uploadAvatar(accountId, avatar) {
 		const formData = new FormData();
 		const name = avatar instanceof File ? avatar.name : "avatar";
 		formData.append("avatar", avatar, name);
-		const { data } = await this.#api.PUT("/accounts/{username}/avatar/", {
-			params: { path: { username } },
+		const { data } = await this.#api.PUT("/accounts/{accountId}/avatar/", {
+			params: { path: { accountId } },
 			body: formData,
 			bodySerializer: (formData) => formData,
 			headers: { "Content-Type": null }
@@ -67,12 +67,12 @@ var Account = class {
 	}
 	/**
 	* Delete an account's avatar image
-	* @param username - Account username
+	* @param accountId - Account id
 	* @returns Promise that resolves when the avatar is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteAvatar(username) {
-		await this.#api.DELETE("/accounts/{username}/avatar/", { params: { path: { username } } });
+	async deleteAvatar(accountId) {
+		await this.#api.DELETE("/accounts/{accountId}/avatar/", { params: { path: { accountId } } });
 	}
 	/**
 	* List the account's sign-in methods: its password and linked providers.
@@ -172,31 +172,31 @@ var Activities = class {
 	}
 	/**
 	* List activities for a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional filters and pagination (type, actor, from, to,
 	*   limit, after, includeCount)
 	* @returns Promise that resolves with a paginated list of activities
 	* @throws {ApiError} if the request fails
 	*/
-	async listActivities(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/activities/", { params: {
-			path: { workspaceSlug },
+	async listActivities(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/activities/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* Export the workspace's activity log as a file.
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional filters (type, actor), date window (from, to), and
 	*   output format (`csv` default, or `json`)
 	* @returns Promise that resolves with the file response
 	* @throws {ApiError} if the request fails
 	*/
-	async exportActivities(workspaceSlug, query) {
-		const { response } = await this.#api.GET("/workspaces/{workspaceSlug}/activities/export", {
+	async exportActivities(workspaceId, query) {
+		const { response } = await this.#api.GET("/workspaces/{workspaceId}/activities/export", {
 			params: {
-				path: { workspaceSlug },
+				path: { workspaceId },
 				query
 			},
 			parseAs: "stream"
@@ -217,24 +217,24 @@ var Analytics = class {
 	}
 	/**
 	* Get aggregate analytics for a workspace: storage, detection health, usage.
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @returns Promise that resolves with the workspace analytics
 	* @throws {ApiError} if the request fails
 	*/
-	async getAnalytics(workspaceSlug) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/analytics/", { params: { path: { workspaceSlug } } });
+	async getAnalytics(workspaceId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/analytics/", { params: { path: { workspaceId } } });
 		return data;
 	}
 	/**
 	* Get a workspace's daily detection activity over a date window.
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional date window (`from` / `to`, YYYY-MM-DD)
 	* @returns Promise that resolves with the detection time series
 	* @throws {ApiError} if the request fails
 	*/
-	async getDetectionTimeSeries(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/analytics/detections/timeseries/", { params: {
-			path: { workspaceSlug },
+	async getDetectionTimeSeries(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/analytics/detections/timeseries/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
@@ -306,97 +306,6 @@ var ApiTokens = class {
 	}
 };
 
-//#endregion
-//#region src/services/assignments.ts
-/**
-* Service for file assignments: assigning a file to a reviewer and tracking its
-* review status (`assigned` → `in_review` → `done`).
-*/
-var Assignments = class {
-	#api;
-	constructor(api) {
-		this.#api = api;
-	}
-	/**
-	* List the assignments on a file, most recent first.
-	* @param workspaceSlug - Workspace slug
-	* @param fileId - File ID
-	* @returns Promise that resolves with the file's assignments
-	* @throws {ApiError} if the request fails
-	*/
-	async listFileAssignments(workspaceSlug, fileId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/files/{fileId}/assignments/", { params: { path: {
-			workspaceSlug,
-			fileId
-		} } });
-		return data;
-	}
-	/**
-	* Assign a file to a reviewer.
-	* @param workspaceSlug - Workspace slug
-	* @param fileId - File ID
-	* @param assignment - Assignment creation request
-	* @returns Promise that resolves with the created assignment
-	* @throws {ApiError} if the request fails
-	*/
-	async createAssignment(workspaceSlug, fileId, assignment) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/files/{fileId}/assignments/", {
-			params: { path: {
-				workspaceSlug,
-				fileId
-			} },
-			body: assignment
-		});
-		return data;
-	}
-	/**
-	* List a workspace's assignments, most recent first.
-	* @param workspaceSlug - Workspace slug
-	* @param query - Optional pagination and filters (assignee, status, fileId,
-	*   limit, after)
-	* @returns Promise that resolves with a paginated list of assignments
-	* @throws {ApiError} if the request fails
-	*/
-	async listAssignments(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/assignments/", { params: {
-			path: { workspaceSlug },
-			query
-		} });
-		return data;
-	}
-	/**
-	* Update an assignment (e.g. change its review status).
-	* @param workspaceSlug - Workspace slug
-	* @param assignmentId - Assignment ID
-	* @param updates - Assignment update request
-	* @returns Promise that resolves with the updated assignment
-	* @throws {ApiError} if the request fails
-	*/
-	async updateAssignment(workspaceSlug, assignmentId, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/assignments/{assignmentId}/", {
-			params: { path: {
-				workspaceSlug,
-				assignmentId
-			} },
-			body: updates
-		});
-		return data;
-	}
-	/**
-	* Delete an assignment.
-	* @param workspaceSlug - Workspace slug
-	* @param assignmentId - Assignment ID
-	* @returns Promise that resolves when the assignment is deleted
-	* @throws {ApiError} if the request fails
-	*/
-	async deleteAssignment(workspaceSlug, assignmentId) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/assignments/{assignmentId}/", { params: { path: {
-			workspaceSlug,
-			assignmentId
-		} } });
-	}
-};
-
 //#endregion
 //#region src/services/auth.ts
 /**
@@ -481,12 +390,13 @@ var Auth = class {
 };
 
 //#endregion
-//#region src/services/catalog.ts
+//#region src/services/capabilities.ts
 /**
-* Service for reading the deployment's built-in catalogs: the label taxonomy
-* and the registered recognizers that policies and pipelines can target.
+* Service for reading the deployment's capabilities: the label taxonomy, the
+* registered recognizers, the connectors it can create, and the auth methods
+* it offers. Read-only; served by the `/capabilities/*` endpoints.
 */
-var Catalog = class {
+var Capabilities = class {
 	#api;
 	constructor(api) {
 		this.#api = api;
@@ -496,7 +406,7 @@ var Catalog = class {
 	* @returns Promise that resolves with the label catalog.
 	*/
 	async listLabels() {
-		const { data } = await this.#api.GET("/catalog/labels/");
+		const { data } = await this.#api.GET("/capabilities/labels/");
 		return data;
 	}
 	/**
@@ -504,7 +414,7 @@ var Catalog = class {
 	* @returns Promise that resolves with the recognizer catalog.
 	*/
 	async listRecognizers() {
-		const { data } = await this.#api.GET("/catalog/recognizers/");
+		const { data } = await this.#api.GET("/capabilities/recognizers/");
 		return data;
 	}
 	/**
@@ -515,177 +425,20 @@ var Catalog = class {
 	* credentials and are always available. Use it to render the connect UI
 	* without probing.
 	*
-	* @returns Promise that resolves with the connector catalog.
+	* @returns Promise that resolves with the connector capabilities.
 	*/
 	async listConnectors() {
-		const { data } = await this.#api.GET("/catalog/connectors/");
-		return data;
-	}
-};
-
-//#endregion
-//#region src/services/sse.ts
-/** Parse one already-split frame (its lines) into an event, or null if empty. */
-function parseFrame(frame) {
-	let event = "message";
-	const data = [];
-	for (const line of frame.split("\n")) {
-		if (line === "" || line.startsWith(":")) continue;
-		const colon = line.indexOf(":");
-		const field = colon === -1 ? line : line.slice(0, colon);
-		let value = colon === -1 ? "" : line.slice(colon + 1);
-		if (value.startsWith(" ")) value = value.slice(1);
-		if (field === "event") event = value;
-		else if (field === "data") data.push(value);
-	}
-	if (data.length === 0) return null;
-	return {
-		event,
-		data: data.join("\n")
-	};
-}
-/**
-* Decode a byte stream into SSE events.
-*
-* @param stream - the response body, a stream of UTF-8 bytes
-* @yields each complete SSE event as it arrives
-*/
-async function* parseSseStream(stream) {
-	const decoder = new TextDecoder();
-	let buffer = "";
-	const reader = stream.getReader();
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			buffer = buffer.replace(/\r\n|\r/g, "\n");
-			let sep = buffer.indexOf("\n\n");
-			while (sep !== -1) {
-				const frame = buffer.slice(0, sep);
-				buffer = buffer.slice(sep + 2);
-				const parsed = parseFrame(frame);
-				if (parsed) yield parsed;
-				sep = buffer.indexOf("\n\n");
-			}
-		}
-		buffer += decoder.decode();
-		const parsed = parseFrame(buffer.replace(/\r\n|\r/g, "\n"));
-		if (parsed) yield parsed;
-	} finally {
-		reader.releaseLock();
-	}
-}
-
-//#endregion
-//#region src/services/chat.ts
-/**
-* Service for the workspace assistant chat: sessions and streamed messages.
-*/
-var Chat = class {
-	#api;
-	constructor(api) {
-		this.#api = api;
-	}
-	/**
-	* List the workspace's chat sessions, most recently active first.
-	* @param workspaceSlug - Workspace slug
-	* @param query - Optional pagination (limit, after)
-	* @returns Promise that resolves with a paginated list of chat sessions
-	* @throws {ApiError} if the request fails
-	*/
-	async listSessions(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/chat/sessions/", { params: {
-			path: { workspaceSlug },
-			query
-		} });
+		const { data } = await this.#api.GET("/capabilities/connectors/");
 		return data;
 	}
 	/**
-	* Open a new assistant chat session in the workspace.
-	* @param workspaceSlug - Workspace slug
-	* @param session - Session creation request
-	* @returns Promise that resolves with the created chat session
-	* @throws {ApiError} if the request fails
-	*/
-	async createSession(workspaceSlug, session) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/chat/sessions/", {
-			params: { path: { workspaceSlug } },
-			body: session
-		});
-		return data;
-	}
-	/**
-	* Soft-delete a chat session.
-	* @param workspaceSlug - Workspace slug
-	* @param sessionId - Session ID
-	* @throws {ApiError} if the request fails
-	*/
-	async deleteSession(workspaceSlug, sessionId) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/chat/sessions/{sessionId}/", { params: { path: {
-			workspaceSlug,
-			sessionId
-		} } });
-	}
-	/**
-	* List a session's messages in chronological order.
-	* @param workspaceSlug - Workspace slug
-	* @param sessionId - Session ID
-	* @returns Promise that resolves with the session's messages
-	* @throws {ApiError} if the request fails
+	* List which authentication methods this deployment offers.
+	* @returns Promise that resolves with the auth capabilities.
 	*/
-	async listMessages(workspaceSlug, sessionId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/chat/sessions/{sessionId}/messages/", { params: { path: {
-			workspaceSlug,
-			sessionId
-		} } });
+	async getAuthCapabilities() {
+		const { data } = await this.#api.GET("/capabilities/auth/");
 		return data;
 	}
-	/**
-	* Open the raw Server-Sent Events stream of the assistant's reply.
-	*
-	* Returns the underlying `Response` so callers can handle the
-	* `text/event-stream` body themselves. Most callers want
-	* {@link streamMessage}, which parses each frame into a typed
-	* {@link ChatToken}.
-	*
-	* @param workspaceSlug - Workspace slug
-	* @param sessionId - Session ID
-	* @param message - The message to send
-	* @returns Promise that resolves with the event-stream response
-	* @throws {ApiError} if the request fails
-	*/
-	async sendMessage(workspaceSlug, sessionId, message) {
-		const { response } = await this.#api.POST("/workspaces/{workspaceSlug}/chat/sessions/{sessionId}/messages/", {
-			params: { path: {
-				workspaceSlug,
-				sessionId
-			} },
-			body: message,
-			parseAs: "stream"
-		});
-		return response;
-	}
-	/**
-	* Send a message and stream the assistant's reply as Server-Sent Events.
-	*
-	* Yields each {@link ChatToken} delta as it arrives, until the reply ends.
-	* Break out of the loop to stop reading. For the raw response, use
-	* {@link sendMessage}.
-	*
-	* @param workspaceSlug - Workspace slug
-	* @param sessionId - Session ID
-	* @param message - The message to send
-	* @yields each {@link ChatToken} delta as it arrives
-	* @throws {ApiError} if the request fails to open
-	* @throws {NvisyError} if the response has no readable body
-	*/
-	async *streamMessage(workspaceSlug, sessionId, message) {
-		const response = await this.sendMessage(workspaceSlug, sessionId, message);
-		if (!response.body) throw new NvisyError("Chat stream response has no body");
-		for await (const event of parseSseStream(response.body)) if (event.event === "token") yield JSON.parse(event.data);
-		else if (event.event === "error") throw new NvisyError(event.data);
-	}
 };
 
 //#endregion
@@ -700,58 +453,58 @@ var Connections = class {
 	}
 	/**
 	* List connections in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional query parameters (provider, limit, after)
 	* @returns Promise that resolves with a paginated list of connections
 	* @throws {ApiError} if the request fails
 	*/
-	async listConnections(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/connections/", { params: {
-			path: { workspaceSlug },
+	async listConnections(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/connections/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* Create a connection in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connection - Connection creation request
 	* @returns Promise that resolves with the created connection
 	* @throws {ApiError} if the request fails
 	*/
-	async createConnection(workspaceSlug, connection) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/", {
-			params: { path: { workspaceSlug } },
+	async createConnection(workspaceId, connection) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/", {
+			params: { path: { workspaceId } },
 			body: connection
 		});
 		return data;
 	}
 	/**
 	* Get connection details by ID
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @returns Promise that resolves with the connection details
 	* @throws {ApiError} if the request fails
 	*/
-	async getConnection(workspaceSlug, connectionId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/connections/{connectionId}/", { params: { path: {
-			workspaceSlug,
+	async getConnection(workspaceId, connectionId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/connections/{connectionId}/", { params: { path: {
+			workspaceId,
 			connectionId
 		} } });
 		return data;
 	}
 	/**
 	* Update a connection
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @param updates - Connection update request
 	* @returns Promise that resolves with the updated connection
 	* @throws {ApiError} if the request fails
 	*/
-	async updateConnection(workspaceSlug, connectionId, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/connections/{connectionId}/", {
+	async updateConnection(workspaceId, connectionId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/connections/{connectionId}/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				connectionId
 			} },
 			body: updates
@@ -760,27 +513,27 @@ var Connections = class {
 	}
 	/**
 	* Delete a connection
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @returns Promise that resolves when the connection is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteConnection(workspaceSlug, connectionId) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/connections/{connectionId}/", { params: { path: {
-			workspaceSlug,
+	async deleteConnection(workspaceId, connectionId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/connections/{connectionId}/", { params: { path: {
+			workspaceId,
 			connectionId
 		} } });
 	}
 	/**
 	* Verify a connection's configuration and credentials
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @returns Promise that resolves with the verification result
 	* @throws {ApiError} if the request fails
 	*/
-	async verifyConnection(workspaceSlug, connectionId) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/{connectionId}/verify/", { params: { path: {
-			workspaceSlug,
+	async verifyConnection(workspaceId, connectionId) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/{connectionId}/verify/", { params: { path: {
+			workspaceId,
 			connectionId
 		} } });
 		return data;
@@ -792,16 +545,16 @@ var Connections = class {
 	* provider redirects back and the connection is created. Navigate the
 	* browser to the URL (a full-page redirect, not a fetch) to continue.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param provider - The file-service provider to connect
 	* @param request - Display name for the connection and optional sync root
 	* @returns Promise that resolves with the provider authorize URL
 	* @throws {ApiError} if the request fails
 	*/
-	async startFileServiceOAuth(workspaceSlug, provider, request) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/oauth/{provider}/start/", {
+	async startFileServiceOAuth(workspaceId, provider, request) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/oauth/{provider}/start/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				provider
 			} },
 			body: request
@@ -815,16 +568,16 @@ var Connections = class {
 	* already-imported files are skipped. Returns the created sync — poll it for
 	* completion.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @param request - The picker-selected files to import
 	* @returns Promise that resolves with the created connection sync
 	* @throws {ApiError} if the request fails
 	*/
-	async importFiles(workspaceSlug, connectionId, request) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/{connectionId}/import/", {
+	async importFiles(workspaceId, connectionId, request) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/{connectionId}/import/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				connectionId
 			} },
 			body: request
@@ -838,16 +591,16 @@ var Connections = class {
 	* file, never overwriting the source. Returns the created sync — poll it for
 	* completion.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @param request - The workspace file ids to export
 	* @returns Promise that resolves with the created connection sync
 	* @throws {ApiError} if the request fails
 	*/
-	async exportFiles(workspaceSlug, connectionId, request) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/{connectionId}/export/", {
+	async exportFiles(workspaceId, connectionId, request) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/{connectionId}/export/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				connectionId
 			} },
 			body: request
@@ -861,16 +614,16 @@ var Connections = class {
 	* minted from the connection's stored credentials and is short-lived; the
 	* refresh token is never returned.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @param request - Optional picker resource (defaults to the connection's)
 	* @returns Promise that resolves with the short-lived picker token
 	* @throws {ApiError} if the request fails
 	*/
-	async getPickerToken(workspaceSlug, connectionId, request = {}) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/{connectionId}/picker-token/", {
+	async getPickerToken(workspaceId, connectionId, request = {}) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/{connectionId}/picker-token/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				connectionId
 			} },
 			body: request
@@ -879,6 +632,60 @@ var Connections = class {
 	}
 };
 
+//#endregion
+//#region src/services/sse.ts
+/** Parse one already-split frame (its lines) into an event, or null if empty. */
+function parseFrame(frame) {
+	let event = "message";
+	const data = [];
+	for (const line of frame.split("\n")) {
+		if (line === "" || line.startsWith(":")) continue;
+		const colon = line.indexOf(":");
+		const field = colon === -1 ? line : line.slice(0, colon);
+		let value = colon === -1 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		if (field === "event") event = value;
+		else if (field === "data") data.push(value);
+	}
+	if (data.length === 0) return null;
+	return {
+		event,
+		data: data.join("\n")
+	};
+}
+/**
+* Decode a byte stream into SSE events.
+*
+* @param stream - the response body, a stream of UTF-8 bytes
+* @yields each complete SSE event as it arrives
+*/
+async function* parseSseStream(stream) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const reader = stream.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			buffer = buffer.replace(/\r\n|\r/g, "\n");
+			let sep = buffer.indexOf("\n\n");
+			while (sep !== -1) {
+				const frame = buffer.slice(0, sep);
+				buffer = buffer.slice(sep + 2);
+				const parsed = parseFrame(frame);
+				if (parsed) yield parsed;
+				sep = buffer.indexOf("\n\n");
+			}
+		}
+		buffer += decoder.decode();
+		const parsed = parseFrame(buffer.replace(/\r\n|\r/g, "\n"));
+		if (parsed) yield parsed;
+	} finally {
+		reader.releaseLock();
+	}
+}
+
 //#endregion
 //#region src/services/detections.ts
 /**
@@ -892,33 +699,33 @@ var Detections = class {
 	}
 	/**
 	* List all detections in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional pagination and filters (status, fileId,
 	*   pipelineId, triggerType, triggeredBy, limit, after)
 	* @returns Promise that resolves with a paginated list of detections
 	* @throws {ApiError} if the request fails
 	*/
-	async listDetections(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/pipelines/detections/", { params: {
-			path: { workspaceSlug },
+	async listDetections(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/pipelines/detections/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* List detections for a specific pipeline
-	* @param workspaceSlug - Workspace slug
-	* @param pipelineSlug - Pipeline slug
+	* @param workspaceId - Workspace id
+	* @param pipelineId - Pipeline id
 	* @param query - Optional pagination and filters (status, fileId,
 	*   triggerType, triggeredBy, limit, after)
 	* @returns Promise that resolves with a paginated list of detections
 	* @throws {ApiError} if the request fails
 	*/
-	async listPipelineDetections(workspaceSlug, pipelineSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/pipelines/{pipelineSlug}/detections/", { params: {
+	async listPipelineDetections(workspaceId, pipelineId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/pipelines/{pipelineId}/detections/", { params: {
 			path: {
-				workspaceSlug,
-				pipelineSlug
+				workspaceId,
+				pipelineId
 			},
 			query
 		} });
@@ -926,46 +733,60 @@ var Detections = class {
 	}
 	/**
 	* Start a new detection over a file for a pipeline
-	* @param workspaceSlug - Workspace slug
-	* @param pipelineSlug - Pipeline slug
+	* @param workspaceId - Workspace id
+	* @param pipelineId - Pipeline id
 	* @param detection - Detection creation request
 	* @returns Promise that resolves with the created detection
 	* @throws {ApiError} if the request fails
 	*/
-	async createDetection(workspaceSlug, pipelineSlug, detection) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/pipelines/{pipelineSlug}/detections/", {
+	async createDetection(workspaceId, pipelineId, detection) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/pipelines/{pipelineId}/detections/", {
 			params: { path: {
-				workspaceSlug,
-				pipelineSlug
+				workspaceId,
+				pipelineId
 			} },
 			body: detection
 		});
 		return data;
 	}
 	/**
+	* Start an ad-hoc detection over a document without a saved pipeline.
+	* @param workspaceId - Workspace id
+	* @param detection - Ad-hoc detection creation request
+	* @returns Promise that resolves with the created detection
+	* @throws {ApiError} if the request fails
+	*/
+	async createAdhocDetection(workspaceId, detection) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/detections/", {
+			params: { path: { workspaceId } },
+			body: detection
+		});
+		return data;
+	}
+	/**
 	* Get detection details by ID
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @returns Promise that resolves with the detection details
 	* @throws {ApiError} if the request fails
 	*/
-	async getDetection(workspaceSlug, detectionId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/detections/{detectionId}/", { params: { path: {
-			workspaceSlug,
+	async getDetection(workspaceId, detectionId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/detections/{detectionId}/", { params: { path: {
+			workspaceId,
 			detectionId
 		} } });
 		return data;
 	}
 	/**
 	* Get a detection's analysis (audit)
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @returns Promise that resolves with the audit
 	* @throws {ApiError} if the request fails
 	*/
-	async getAnalysis(workspaceSlug, detectionId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/detections/{detectionId}/analysis/", { params: { path: {
-			workspaceSlug,
+	async getAnalysis(workspaceId, detectionId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/detections/{detectionId}/analysis/", { params: { path: {
+			workspaceId,
 			detectionId
 		} } });
 		return data;
@@ -978,14 +799,14 @@ var Detections = class {
 	* can search the extracted content and add entities the analysis missed. A
 	* detection whose analysis ran no enricher has no intermediates and 404s.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @returns Promise that resolves with the artifact set
 	* @throws {ApiError} if the request fails (404 when there are none)
 	*/
-	async getIntermediates(workspaceSlug, detectionId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/detections/{detectionId}/intermediates/", { params: { path: {
-			workspaceSlug,
+	async getIntermediates(workspaceId, detectionId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/detections/{detectionId}/intermediates/", { params: { path: {
+			workspaceId,
 			detectionId
 		} } });
 		return data;
@@ -996,17 +817,17 @@ var Detections = class {
 	* `format` is `csv` (default) — a zip of entities.csv, provenance.csv, and
 	* reviews.csv — or `json`, a pretty-printed JSON file.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @param query - Optional output format (`csv` default, or `json`)
 	* @returns Promise that resolves with the file response
 	* @throws {ApiError} if the request fails
 	*/
-	async downloadAudit(workspaceSlug, detectionId, query) {
-		const { response } = await this.#api.GET("/workspaces/{workspaceSlug}/detections/{detectionId}/audit/", {
+	async downloadAudit(workspaceId, detectionId, query) {
+		const { response } = await this.#api.GET("/workspaces/{workspaceId}/detections/{detectionId}/audit/", {
 			params: {
 				path: {
-					workspaceSlug,
+					workspaceId,
 					detectionId
 				},
 				query
@@ -1023,15 +844,15 @@ var Detections = class {
 	* {@link streamEvents}, which parses each frame into a typed
 	* {@link DetectionStatusEvent}.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @returns Promise that resolves with the event-stream response
 	* @throws {ApiError} if the request fails
 	*/
-	async events(workspaceSlug, detectionId) {
-		const { response } = await this.#api.GET("/workspaces/{workspaceSlug}/detections/{detectionId}/events/", {
+	async events(workspaceId, detectionId) {
+		const { response } = await this.#api.GET("/workspaces/{workspaceId}/detections/{detectionId}/events/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				detectionId
 			} },
 			parseAs: "stream"
@@ -1045,29 +866,29 @@ var Detections = class {
 	* once the detection settles. Break out of the loop to close the stream
 	* early. For the raw response, use {@link events}.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @yields each {@link DetectionStatusEvent} as it arrives
 	* @throws {ApiError} if the request fails to open
 	* @throws {NvisyError} if the response has no readable body
 	*/
-	async *streamEvents(workspaceSlug, detectionId) {
-		const response = await this.events(workspaceSlug, detectionId);
+	async *streamEvents(workspaceId, detectionId) {
+		const response = await this.events(workspaceId, detectionId);
 		if (!response.body) throw new NvisyError("Event stream response has no body");
 		for await (const event of parseSseStream(response.body)) if (event.event === "status") yield JSON.parse(event.data);
 	}
 	/**
 	* List the redactions produced from a detection
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @param query - Optional pagination (limit, after)
 	* @returns Promise that resolves with a paginated list of redactions
 	* @throws {ApiError} if the request fails
 	*/
-	async listRedactions(workspaceSlug, detectionId, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/detections/{detectionId}/redactions/", { params: {
+	async listRedactions(workspaceId, detectionId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/detections/{detectionId}/redactions/", { params: {
 			path: {
-				workspaceSlug,
+				workspaceId,
 				detectionId
 			},
 			query
@@ -1076,16 +897,16 @@ var Detections = class {
 	}
 	/**
 	* Redact a detection, producing a redaction result
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param detectionId - Detection ID
 	* @param redaction - Redaction request (optional reviewer edits)
 	* @returns Promise that resolves with the created redaction result
 	* @throws {ApiError} if the request fails
 	*/
-	async createRedaction(workspaceSlug, detectionId, redaction) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/detections/{detectionId}/redactions/", {
+	async createRedaction(workspaceId, detectionId, redaction) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/detections/{detectionId}/redactions/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				detectionId
 			} },
 			body: redaction
@@ -1095,31 +916,31 @@ var Detections = class {
 };
 
 //#endregion
-//#region src/services/files.ts
+//#region src/services/documents.ts
 /**
-* Service for handling file operations
+* Service for handling document operations, including review assignment.
 */
-var Files = class {
+var Documents = class {
 	#api;
 	constructor(api) {
 		this.#api = api;
 	}
 	/**
-	* Upload one or more files to a workspace
-	* @param workspaceSlug - Workspace slug
-	* @param files - File or array of files to upload
-	* @returns Promise that resolves with the uploaded file metadata
+	* Upload one or more documents to a workspace
+	* @param workspaceId - Workspace id
+	* @param documents - Document or array of documents to upload
+	* @returns Promise that resolves with the uploaded document metadata
 	* @throws {ApiError} if the request fails
 	*/
-	async uploadFiles(workspaceSlug, files) {
+	async uploadDocuments(workspaceId, documents) {
 		const formData = new FormData();
-		const fileArray = Array.isArray(files) ? files : [files];
-		for (const file of fileArray) {
-			const name = file instanceof File ? file.name : "file";
-			formData.append("files", file, name);
+		const documentArray = Array.isArray(documents) ? documents : [documents];
+		for (const document of documentArray) {
+			const name = document instanceof File ? document.name : "document";
+			formData.append("documents", document, name);
 		}
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/files/", {
-			params: { path: { workspaceSlug } },
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/documents/", {
+			params: { path: { workspaceId } },
 			body: formData,
 			bodySerializer: (formData) => formData,
 			headers: { "Content-Type": null }
@@ -1127,101 +948,133 @@ var Files = class {
 		return data;
 	}
 	/**
-	* List files in a workspace
-	* @param workspaceSlug - Workspace slug
+	* List documents in a workspace
+	* @param workspaceId - Workspace id
 	* @param query - Optional query parameters (formats, modality, hash, search,
 	*   limit, after)
-	* @returns Promise that resolves with a paginated list of files
+	* @returns Promise that resolves with a paginated list of documents
 	* @throws {ApiError} if the request fails
 	*/
-	async listFiles(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/files/", { params: {
-			path: { workspaceSlug },
+	async listDocuments(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/documents/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
-	* Get file metadata by ID
-	* @param workspaceSlug - Workspace slug
-	* @param fileId - File ID
-	* @returns Promise that resolves with the file metadata
+	* Get document metadata by ID
+	* @param workspaceId - Workspace id
+	* @param documentId - Document ID
+	* @returns Promise that resolves with the document metadata
 	* @throws {ApiError} if the request fails
 	*/
-	async getFile(workspaceSlug, fileId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/files/{fileId}/", { params: { path: {
-			workspaceSlug,
-			fileId
+	async getDocument(workspaceId, documentId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/documents/{documentId}/", { params: { path: {
+			workspaceId,
+			documentId
 		} } });
 		return data;
 	}
 	/**
-	* Download a file by ID
-	* @param workspaceSlug - Workspace slug
-	* @param fileId - File ID
-	* @returns Promise that resolves with the file response
+	* Download a document by ID
+	* @param workspaceId - Workspace id
+	* @param documentId - Document ID
+	* @returns Promise that resolves with the document response
 	* @throws {ApiError} if the request fails
 	*/
-	async downloadFile(workspaceSlug, fileId) {
-		const { response } = await this.#api.GET("/workspaces/{workspaceSlug}/files/{fileId}/content/", {
+	async downloadDocument(workspaceId, documentId) {
+		const { response } = await this.#api.GET("/workspaces/{workspaceId}/documents/{documentId}/content/", {
 			params: { path: {
-				workspaceSlug,
-				fileId
+				workspaceId,
+				documentId
 			} },
 			parseAs: "stream"
 		});
 		return response;
 	}
 	/**
-	* Update a file's metadata
-	* @param workspaceSlug - Workspace slug
-	* @param fileId - File ID
-	* @param updates - File update request
-	* @returns Promise that resolves with the updated file
+	* Update a document's metadata
+	* @param workspaceId - Workspace id
+	* @param documentId - Document ID
+	* @param updates - Document update request
+	* @returns Promise that resolves with the updated document
 	* @throws {ApiError} if the request fails
 	*/
-	async updateFile(workspaceSlug, fileId, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/files/{fileId}/", {
+	async updateDocument(workspaceId, documentId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/documents/{documentId}/", {
 			params: { path: {
-				workspaceSlug,
-				fileId
+				workspaceId,
+				documentId
 			} },
 			body: updates
 		});
 		return data;
 	}
 	/**
-	* Delete a file
-	* @param workspaceSlug - Workspace slug
-	* @param fileId - File ID
-	* @returns Promise that resolves when the file is deleted
+	* Delete a document
+	* @param workspaceId - Workspace id
+	* @param documentId - Document ID
+	* @returns Promise that resolves when the document is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteFile(workspaceSlug, fileId) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/files/{fileId}/", { params: { path: {
-			workspaceSlug,
-			fileId
+	async deleteDocument(workspaceId, documentId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/documents/{documentId}/", { params: { path: {
+			workspaceId,
+			documentId
 		} } });
 	}
 	/**
-	* Delete several files in one call.
+	* Delete several documents in one call.
 	*
-	* Idempotent: ids resolving to live files in the workspace are removed and
-	* returned in `deleted`; unknown, already-deleted, or out-of-workspace ids
-	* are returned in `skipped`. Deletion is permanent.
+	* Idempotent: ids resolving to live documents in the workspace are removed
+	* and returned in `deleted`; unknown, already-deleted, or out-of-workspace
+	* ids are returned in `skipped`. Deletion is permanent.
 	*
-	* @param workspaceSlug - Workspace slug
-	* @param fileIds - The file IDs to delete
+	* @param workspaceId - Workspace id
+	* @param documentIds - The document IDs to delete
 	* @returns Promise that resolves with the deleted and skipped ids
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteFiles(workspaceSlug, fileIds) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/files/delete/", {
-			params: { path: { workspaceSlug } },
-			body: { fileIds }
+	async deleteDocuments(workspaceId, documentIds) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/documents/delete/", {
+			params: { path: { workspaceId } },
+			body: { documentIds }
 		});
 		return data;
 	}
+	/**
+	* Assign a document for review, opening a review thread.
+	* @param workspaceId - Workspace id
+	* @param documentId - Document ID
+	* @param assignment - Review assignment request
+	* @returns Promise that resolves with the review thread
+	* @throws {ApiError} if the request fails
+	*/
+	async assignReview(workspaceId, documentId, assignment) {
+		const { data } = await this.#api.PUT("/workspaces/{workspaceId}/documents/{documentId}/review/assign/", {
+			params: { path: {
+				workspaceId,
+				documentId
+			} },
+			body: assignment
+		});
+		return data;
+	}
+	/**
+	* Mark a document's review as verified (resolved).
+	* @param workspaceId - Workspace id
+	* @param documentId - Document ID
+	* @returns Promise that resolves with the review thread
+	* @throws {ApiError} if the request fails
+	*/
+	async verifyReview(workspaceId, documentId) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/documents/{documentId}/review/verify/", { params: { path: {
+			workspaceId,
+			documentId
+		} } });
+		return data;
+	}
 };
 
 //#endregion
@@ -1241,52 +1094,52 @@ var Invites = class {
 	* @returns Promise that resolves with a paginated list of invitations
 	* @throws {ApiError} if the request fails
 	*/
-	async listInvites(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/invites/", { params: {
-			path: { workspaceSlug },
+	async listInvites(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/invites/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* Send an invitation to join a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param invite - Invitation request
 	* @returns Promise that resolves with the sent invitation
 	* @throws {ApiError} if the request fails
 	*/
-	async sendInvite(workspaceSlug, invite) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/invites/", {
-			params: { path: { workspaceSlug } },
+	async sendInvite(workspaceId, invite) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/invites/", {
+			params: { path: { workspaceId } },
 			body: invite
 		});
 		return data;
 	}
 	/**
 	* Cancel a pending invitation
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param inviteId - Invite ID
 	* @returns Promise that resolves when the invitation is canceled
 	* @throws {ApiError} if the request fails
 	*/
-	async cancelInvite(workspaceSlug, inviteId) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/invites/{inviteId}/", { params: { path: {
-			workspaceSlug,
+	async cancelInvite(workspaceId, inviteId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/invites/{inviteId}/", { params: { path: {
+			workspaceId,
 			inviteId
 		} } });
 	}
 	/**
 	* Reply to an invitation (accept or decline)
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param inviteId - Invite ID
 	* @param reply - Reply request
 	* @returns Promise that resolves with the updated invitation
 	* @throws {ApiError} if the request fails
 	*/
-	async replyToInvite(workspaceSlug, inviteId, reply) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/invites/{inviteId}/", {
+	async replyToInvite(workspaceId, inviteId, reply) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/invites/{inviteId}/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				inviteId
 			} },
 			body: reply
@@ -1295,14 +1148,14 @@ var Invites = class {
 	}
 	/**
 	* Generate a shareable invite code for a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param options - Invite code generation options
 	* @returns Promise that resolves with the generated invite code
 	* @throws {ApiError} if the request fails
 	*/
-	async generateInviteCode(workspaceSlug, options) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/invites/code/", {
-			params: { path: { workspaceSlug } },
+	async generateInviteCode(workspaceId, options) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/invites/code/", {
+			params: { path: { workspaceId } },
 			body: options
 		});
 		return data;
@@ -1310,16 +1163,16 @@ var Invites = class {
 	/**
 	* Reply to an invite code (accept or decline)
 	* @param inviteCode - The invite code
-	* @param reply - Optional reply request (defaults to accept if not provided)
+	* @param reply - Reply request (accept or decline the invitation)
 	* @returns Promise that resolves with the member details if accepted, null if declined
 	* @throws {ApiError} if the request fails
 	*/
 	async replyToInviteCode(inviteCode, reply) {
 		const { data } = await this.#api.POST("/invites/code/{inviteCode}/", {
 			params: { path: { inviteCode } },
-			body: reply ?? null
+			body: reply
 		});
-		return data;
+		return data ?? null;
 	}
 	/**
 	* Preview an invite code without joining
@@ -1345,45 +1198,45 @@ var Members = class {
 	}
 	/**
 	* List members of a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional query parameters (role, has2fa, sortBy, order, limit, after)
 	* @returns Promise that resolves with a paginated list of members
 	* @throws {ApiError} if the request fails
 	*/
-	async listMembers(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/members/", { params: {
-			path: { workspaceSlug },
+	async listMembers(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/members/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
-	* Get member details by username
-	* @param workspaceSlug - Workspace slug
-	* @param username - Member username
+	* Get member details by account id
+	* @param workspaceId - Workspace id
+	* @param accountId - Member account id
 	* @returns Promise that resolves with the member details
 	* @throws {ApiError} if the request fails
 	*/
-	async getMember(workspaceSlug, username) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/members/{username}/", { params: { path: {
-			workspaceSlug,
-			username
+	async getMember(workspaceId, accountId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/members/{accountId}/", { params: { path: {
+			workspaceId,
+			accountId
 		} } });
 		return data;
 	}
 	/**
 	* Update a member's role
-	* @param workspaceSlug - Workspace slug
-	* @param username - Member username
+	* @param workspaceId - Workspace id
+	* @param accountId - Member account id
 	* @param updates - New role for the member
 	* @returns Promise that resolves with the updated member
 	* @throws {ApiError} if the request fails
 	*/
-	async updateMember(workspaceSlug, username, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/members/{username}/", {
+	async updateMember(workspaceId, accountId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/members/{accountId}/", {
 			params: { path: {
-				workspaceSlug,
-				username
+				workspaceId,
+				accountId
 			} },
 			body: updates
 		});
@@ -1391,25 +1244,25 @@ var Members = class {
 	}
 	/**
 	* Remove a member from a workspace
-	* @param workspaceSlug - Workspace slug
-	* @param username - Member username
+	* @param workspaceId - Workspace id
+	* @param accountId - Member account id
 	* @returns Promise that resolves when the member is removed
 	* @throws {ApiError} if the request fails
 	*/
-	async removeMember(workspaceSlug, username) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/members/{username}/", { params: { path: {
-			workspaceSlug,
-			username
+	async removeMember(workspaceId, accountId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/members/{accountId}/", { params: { path: {
+			workspaceId,
+			accountId
 		} } });
 	}
 	/**
 	* Leave a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @returns Promise that resolves when the member has left
 	* @throws {ApiError} if the request fails
 	*/
-	async leaveWorkspace(workspaceSlug) {
-		await this.#api.POST("/workspaces/{workspaceSlug}/members/leave/", { params: { path: { workspaceSlug } } });
+	async leaveWorkspace(workspaceId) {
+		await this.#api.POST("/workspaces/{workspaceId}/members/leave/", { params: { path: { workspaceId } } });
 	}
 };
 
@@ -1504,59 +1357,59 @@ var Pipelines = class {
 	}
 	/**
 	* List pipelines in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional query parameters (search, status, limit, after)
 	* @returns Promise that resolves with a paginated list of pipeline summaries
 	* @throws {ApiError} if the request fails
 	*/
-	async listPipelines(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/pipelines/", { params: {
-			path: { workspaceSlug },
+	async listPipelines(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/pipelines/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* Create a pipeline in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param pipeline - Pipeline creation request
 	* @returns Promise that resolves with the created pipeline
 	* @throws {ApiError} if the request fails
 	*/
-	async createPipeline(workspaceSlug, pipeline) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/pipelines/", {
-			params: { path: { workspaceSlug } },
+	async createPipeline(workspaceId, pipeline) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/pipelines/", {
+			params: { path: { workspaceId } },
 			body: pipeline
 		});
 		return data;
 	}
 	/**
-	* Get pipeline details by slug
-	* @param workspaceSlug - Workspace slug
-	* @param pipelineSlug - Pipeline slug
+	* Get pipeline details by id
+	* @param workspaceId - Workspace id
+	* @param pipelineId - Pipeline id
 	* @returns Promise that resolves with the pipeline details
 	* @throws {ApiError} if the request fails
 	*/
-	async getPipeline(workspaceSlug, pipelineSlug) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/pipelines/{pipelineSlug}/", { params: { path: {
-			workspaceSlug,
-			pipelineSlug
+	async getPipeline(workspaceId, pipelineId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/pipelines/{pipelineId}/", { params: { path: {
+			workspaceId,
+			pipelineId
 		} } });
 		return data;
 	}
 	/**
 	* Update a pipeline
-	* @param workspaceSlug - Workspace slug
-	* @param pipelineSlug - Pipeline slug
+	* @param workspaceId - Workspace id
+	* @param pipelineId - Pipeline id
 	* @param updates - Pipeline update request
 	* @returns Promise that resolves with the updated pipeline
 	* @throws {ApiError} if the request fails
 	*/
-	async updatePipeline(workspaceSlug, pipelineSlug, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/pipelines/{pipelineSlug}/", {
+	async updatePipeline(workspaceId, pipelineId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/pipelines/{pipelineId}/", {
 			params: { path: {
-				workspaceSlug,
-				pipelineSlug
+				workspaceId,
+				pipelineId
 			} },
 			body: updates
 		});
@@ -1564,15 +1417,15 @@ var Pipelines = class {
 	}
 	/**
 	* Delete a pipeline
-	* @param workspaceSlug - Workspace slug
-	* @param pipelineSlug - Pipeline slug
+	* @param workspaceId - Workspace id
+	* @param pipelineId - Pipeline id
 	* @returns Promise that resolves when the pipeline is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deletePipeline(workspaceSlug, pipelineSlug) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/pipelines/{pipelineSlug}/", { params: { path: {
-			workspaceSlug,
-			pipelineSlug
+	async deletePipeline(workspaceId, pipelineId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/pipelines/{pipelineId}/", { params: { path: {
+			workspaceId,
+			pipelineId
 		} } });
 	}
 };
@@ -1589,59 +1442,59 @@ var Policies = class {
 	}
 	/**
 	* List policies in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional pagination parameters (limit, after)
 	* @returns Promise that resolves with a paginated list of policies
 	* @throws {ApiError} if the request fails
 	*/
-	async listPolicies(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/policies/", { params: {
-			path: { workspaceSlug },
+	async listPolicies(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/policies/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* Create a policy in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param policy - Policy creation request
 	* @returns Promise that resolves with the created policy
 	* @throws {ApiError} if the request fails
 	*/
-	async createPolicy(workspaceSlug, policy) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/policies/", {
-			params: { path: { workspaceSlug } },
+	async createPolicy(workspaceId, policy) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/policies/", {
+			params: { path: { workspaceId } },
 			body: policy
 		});
 		return data;
 	}
 	/**
-	* Get policy details by slug
-	* @param workspaceSlug - Workspace slug
-	* @param policySlug - Policy slug
+	* Get policy details by id
+	* @param workspaceId - Workspace id
+	* @param policyId - Policy id
 	* @returns Promise that resolves with the policy details
 	* @throws {ApiError} if the request fails
 	*/
-	async getPolicy(workspaceSlug, policySlug) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/policies/{policySlug}/", { params: { path: {
-			workspaceSlug,
-			policySlug
+	async getPolicy(workspaceId, policyId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/policies/{policyId}/", { params: { path: {
+			workspaceId,
+			policyId
 		} } });
 		return data;
 	}
 	/**
 	* Update a policy
-	* @param workspaceSlug - Workspace slug
-	* @param policySlug - Policy slug
+	* @param workspaceId - Workspace id
+	* @param policyId - Policy id
 	* @param updates - Policy update request
 	* @returns Promise that resolves with the updated policy
 	* @throws {ApiError} if the request fails
 	*/
-	async updatePolicy(workspaceSlug, policySlug, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/policies/{policySlug}/", {
+	async updatePolicy(workspaceId, policyId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/policies/{policyId}/", {
 			params: { path: {
-				workspaceSlug,
-				policySlug
+				workspaceId,
+				policyId
 			} },
 			body: updates
 		});
@@ -1649,15 +1502,15 @@ var Policies = class {
 	}
 	/**
 	* Delete a policy
-	* @param workspaceSlug - Workspace slug
-	* @param policySlug - Policy slug
+	* @param workspaceId - Workspace id
+	* @param policyId - Policy id
 	* @returns Promise that resolves when the policy is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deletePolicy(workspaceSlug, policySlug) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/policies/{policySlug}/", { params: { path: {
-			workspaceSlug,
-			policySlug
+	async deletePolicy(workspaceId, policyId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/policies/{policyId}/", { params: { path: {
+			workspaceId,
+			policyId
 		} } });
 	}
 };
@@ -1676,58 +1529,58 @@ var Providers = class {
 	}
 	/**
 	* List a workspace's inference providers
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional pagination and filters (provider, limit, after)
 	* @returns Promise that resolves with a paginated list of providers
 	* @throws {ApiError} if the request fails
 	*/
-	async listProviders(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/providers/", { params: {
-			path: { workspaceSlug },
+	async listProviders(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/providers/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* Create an inference provider in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param provider - Provider creation request
 	* @returns Promise that resolves with the created provider
 	* @throws {ApiError} if the request fails
 	*/
-	async createProvider(workspaceSlug, provider) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/providers/", {
-			params: { path: { workspaceSlug } },
+	async createProvider(workspaceId, provider) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/providers/", {
+			params: { path: { workspaceId } },
 			body: provider
 		});
 		return data;
 	}
 	/**
 	* Get provider details by ID
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param providerId - Provider ID
 	* @returns Promise that resolves with the provider details
 	* @throws {ApiError} if the request fails
 	*/
-	async getProvider(workspaceSlug, providerId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/providers/{providerId}/", { params: { path: {
-			workspaceSlug,
+	async getProvider(workspaceId, providerId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/providers/{providerId}/", { params: { path: {
+			workspaceId,
 			providerId
 		} } });
 		return data;
 	}
 	/**
 	* Update an inference provider
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param providerId - Provider ID
 	* @param updates - Provider update request
 	* @returns Promise that resolves with the updated provider
 	* @throws {ApiError} if the request fails
 	*/
-	async updateProvider(workspaceSlug, providerId, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/providers/{providerId}/", {
+	async updateProvider(workspaceId, providerId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/providers/{providerId}/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				providerId
 			} },
 			body: updates
@@ -1736,27 +1589,27 @@ var Providers = class {
 	}
 	/**
 	* Delete an inference provider
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param providerId - Provider ID
 	* @returns Promise that resolves when the provider is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteProvider(workspaceSlug, providerId) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/providers/{providerId}/", { params: { path: {
-			workspaceSlug,
+	async deleteProvider(workspaceId, providerId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/providers/{providerId}/", { params: { path: {
+			workspaceId,
 			providerId
 		} } });
 	}
 	/**
 	* Verify an inference provider's configuration and credentials
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param providerId - Provider ID
 	* @returns Promise that resolves with the verification result
 	* @throws {ApiError} if the request fails
 	*/
-	async verifyProvider(workspaceSlug, providerId) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/providers/{providerId}/verify/", { params: { path: {
-			workspaceSlug,
+	async verifyProvider(workspaceId, providerId) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/providers/{providerId}/verify/", { params: { path: {
+			workspaceId,
 			providerId
 		} } });
 		return data;
@@ -1776,14 +1629,14 @@ var Redactions = class {
 	}
 	/**
 	* Get a redaction's review audit
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param redactionId - Redaction ID
 	* @returns Promise that resolves with the audit
 	* @throws {ApiError} if the request fails
 	*/
-	async getReview(workspaceSlug, redactionId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/redactions/{redactionId}/review", { params: { path: {
-			workspaceSlug,
+	async getReview(workspaceId, redactionId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/redactions/{redactionId}/review", { params: { path: {
+			workspaceId,
 			redactionId
 		} } });
 		return data;
@@ -1822,14 +1675,14 @@ var Syncs = class {
 	}
 	/**
 	* List all syncs across a workspace's connections
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional query parameters (provider, status, limit, after)
 	* @returns Promise that resolves with a paginated list of connection syncs
 	* @throws {ApiError} if the request fails
 	*/
-	async listWorkspaceSyncs(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/syncs/", { params: {
-			path: { workspaceSlug },
+	async listWorkspaceSyncs(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/syncs/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
@@ -1842,30 +1695,30 @@ var Syncs = class {
 	* use {@link Connections.importFiles} and {@link Connections.exportFiles}
 	* instead. Returns the created sync — poll it for completion.
 	*
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @returns Promise that resolves with the started connection sync
 	* @throws {ApiError} if the request fails
 	*/
-	async startSync(workspaceSlug, connectionId) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/{connectionId}/sync/", { params: { path: {
-			workspaceSlug,
+	async startSync(workspaceId, connectionId) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/{connectionId}/sync/", { params: { path: {
+			workspaceId,
 			connectionId
 		} } });
 		return data;
 	}
 	/**
 	* List syncs for a connection
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @param query - Optional pagination parameters (limit, after)
 	* @returns Promise that resolves with a paginated list of connection syncs
 	* @throws {ApiError} if the request fails
 	*/
-	async listSyncs(workspaceSlug, connectionId, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/connections/{connectionId}/syncs/", { params: {
+	async listSyncs(workspaceId, connectionId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/connections/{connectionId}/syncs/", { params: {
 			path: {
-				workspaceSlug,
+				workspaceId,
 				connectionId
 			},
 			query
@@ -1874,15 +1727,15 @@ var Syncs = class {
 	}
 	/**
 	* Get a connection sync by ID
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @param syncId - Sync ID
 	* @returns Promise that resolves with the connection sync details
 	* @throws {ApiError} if the request fails
 	*/
-	async getSync(workspaceSlug, connectionId, syncId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/connections/{connectionId}/syncs/{syncId}/", { params: { path: {
-			workspaceSlug,
+	async getSync(workspaceId, connectionId, syncId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/connections/{connectionId}/syncs/{syncId}/", { params: { path: {
+			workspaceId,
 			connectionId,
 			syncId
 		} } });
@@ -1890,15 +1743,15 @@ var Syncs = class {
 	}
 	/**
 	* Cancel a running connection sync
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param connectionId - Connection ID
 	* @param syncId - Sync ID
 	* @returns Promise that resolves with the canceled connection sync
 	* @throws {ApiError} if the request fails
 	*/
-	async cancelSync(workspaceSlug, connectionId, syncId) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/connections/{connectionId}/syncs/{syncId}/cancel/", { params: { path: {
-			workspaceSlug,
+	async cancelSync(workspaceId, connectionId, syncId) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/{connectionId}/syncs/{syncId}/cancel/", { params: { path: {
+			workspaceId,
 			connectionId,
 			syncId
 		} } });
@@ -1906,6 +1759,172 @@ var Syncs = class {
 	}
 };
 
+//#endregion
+//#region src/services/threads.ts
+/**
+* Service for discussion threads and the comments within them.
+*/
+var Threads = class {
+	#api;
+	constructor(api) {
+		this.#api = api;
+	}
+	/**
+	* List a workspace's threads
+	* @param workspaceId - Workspace id
+	* @param query - Optional pagination and filters (status, limit, after)
+	* @returns Promise that resolves with a paginated list of threads
+	* @throws {ApiError} if the request fails
+	*/
+	async listThreads(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/threads/", { params: {
+			path: { workspaceId },
+			query
+		} });
+		return data;
+	}
+	/**
+	* Open a new thread in a workspace
+	* @param workspaceId - Workspace id
+	* @param thread - Thread creation request
+	* @returns Promise that resolves with the created thread
+	* @throws {ApiError} if the request fails
+	*/
+	async openThread(workspaceId, thread) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/threads/", {
+			params: { path: { workspaceId } },
+			body: thread
+		});
+		return data;
+	}
+	/**
+	* Rename a thread
+	* @param workspaceId - Workspace id
+	* @param threadId - Thread ID
+	* @param updates - Thread rename request
+	* @returns Promise that resolves with the updated thread
+	* @throws {ApiError} if the request fails
+	*/
+	async renameThread(workspaceId, threadId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/threads/{threadId}/", {
+			params: { path: {
+				workspaceId,
+				threadId
+			} },
+			body: updates
+		});
+		return data;
+	}
+	/**
+	* Delete a thread
+	* @param workspaceId - Workspace id
+	* @param threadId - Thread ID
+	* @returns Promise that resolves when the thread is deleted
+	* @throws {ApiError} if the request fails
+	*/
+	async deleteThread(workspaceId, threadId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/threads/{threadId}/", { params: { path: {
+			workspaceId,
+			threadId
+		} } });
+	}
+	/**
+	* Close a thread, ending the discussion.
+	* @param workspaceId - Workspace id
+	* @param threadId - Thread ID
+	* @returns Promise that resolves with the closed thread
+	* @throws {ApiError} if the request fails
+	*/
+	async closeThread(workspaceId, threadId) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/threads/{threadId}/close/", { params: { path: {
+			workspaceId,
+			threadId
+		} } });
+		return data;
+	}
+	/**
+	* Reopen a closed thread.
+	* @param workspaceId - Workspace id
+	* @param threadId - Thread ID
+	* @returns Promise that resolves with the reopened thread
+	* @throws {ApiError} if the request fails
+	*/
+	async reopenThread(workspaceId, threadId) {
+		const { data } = await this.#api.DELETE("/workspaces/{workspaceId}/threads/{threadId}/close/", { params: { path: {
+			workspaceId,
+			threadId
+		} } });
+		return data;
+	}
+	/**
+	* List a thread's timeline: comments interleaved with lifecycle events.
+	* @param workspaceId - Workspace id
+	* @param threadId - Thread ID
+	* @param query - Optional pagination parameters (limit, after)
+	* @returns Promise that resolves with a paginated timeline
+	* @throws {ApiError} if the request fails
+	*/
+	async listTimeline(workspaceId, threadId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/threads/{threadId}/timeline/", { params: {
+			path: {
+				workspaceId,
+				threadId
+			},
+			query
+		} });
+		return data;
+	}
+	/**
+	* Post a comment to a thread
+	* @param workspaceId - Workspace id
+	* @param threadId - Thread ID
+	* @param comment - Comment creation request
+	* @returns Promise that resolves with the created comment
+	* @throws {ApiError} if the request fails
+	*/
+	async createComment(workspaceId, threadId, comment) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/threads/{threadId}/comments/", {
+			params: { path: {
+				workspaceId,
+				threadId
+			} },
+			body: comment
+		});
+		return data;
+	}
+	/**
+	* Edit a comment
+	* @param workspaceId - Workspace id
+	* @param commentId - Comment ID
+	* @param updates - Comment update request
+	* @returns Promise that resolves with the updated comment
+	* @throws {ApiError} if the request fails
+	*/
+	async updateComment(workspaceId, commentId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/comments/{commentId}/", {
+			params: { path: {
+				workspaceId,
+				commentId
+			} },
+			body: updates
+		});
+		return data;
+	}
+	/**
+	* Delete a comment
+	* @param workspaceId - Workspace id
+	* @param commentId - Comment ID
+	* @returns Promise that resolves when the comment is deleted
+	* @throws {ApiError} if the request fails
+	*/
+	async deleteComment(workspaceId, commentId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/comments/{commentId}/", { params: { path: {
+			workspaceId,
+			commentId
+		} } });
+	}
+};
+
 //#endregion
 //#region src/services/webhooks.ts
 /**
@@ -1918,58 +1937,58 @@ var Webhooks = class {
 	}
 	/**
 	* List all webhooks in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param query - Optional pagination parameters (limit, after)
 	* @returns Promise that resolves with a paginated list of webhooks
 	* @throws {ApiError} if the request fails
 	*/
-	async listWebhooks(workspaceSlug, query) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/webhooks/", { params: {
-			path: { workspaceSlug },
+	async listWebhooks(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/webhooks/", { params: {
+			path: { workspaceId },
 			query
 		} });
 		return data;
 	}
 	/**
 	* Create a new webhook
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param webhook - Webhook creation request
 	* @returns Promise that resolves with the created webhook (including secret)
 	* @throws {ApiError} if the request fails
 	*/
-	async createWebhook(workspaceSlug, webhook) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/webhooks/", {
-			params: { path: { workspaceSlug } },
+	async createWebhook(workspaceId, webhook) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/webhooks/", {
+			params: { path: { workspaceId } },
 			body: webhook
 		});
 		return data;
 	}
 	/**
-	* Get a specific webhook by slug
-	* @param workspaceSlug - Workspace slug
+	* Get a specific webhook by id
+	* @param workspaceId - Workspace id
 	* @param webhookId - Webhook ID
 	* @returns Promise that resolves with the webhook details
 	* @throws {ApiError} if the request fails
 	*/
-	async getWebhook(workspaceSlug, webhookId) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/webhooks/{webhookId}/", { params: { path: {
-			workspaceSlug,
+	async getWebhook(workspaceId, webhookId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/webhooks/{webhookId}/", { params: { path: {
+			workspaceId,
 			webhookId
 		} } });
 		return data;
 	}
 	/**
 	* Update an existing webhook
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param webhookId - Webhook ID
 	* @param updates - Webhook update request
 	* @returns Promise that resolves with the updated webhook
 	* @throws {ApiError} if the request fails
 	*/
-	async updateWebhook(workspaceSlug, webhookId, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/webhooks/{webhookId}/", {
+	async updateWebhook(workspaceId, webhookId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/webhooks/{webhookId}/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				webhookId
 			} },
 			body: updates
@@ -1978,29 +1997,29 @@ var Webhooks = class {
 	}
 	/**
 	* Delete a webhook
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param webhookId - Webhook ID
 	* @returns Promise that resolves when the webhook is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteWebhook(workspaceSlug, webhookId) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/webhooks/{webhookId}/", { params: { path: {
-			workspaceSlug,
+	async deleteWebhook(workspaceId, webhookId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/webhooks/{webhookId}/", { params: { path: {
+			workspaceId,
 			webhookId
 		} } });
 	}
 	/**
 	* Test a webhook by sending a test payload
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param webhookId - Webhook ID
 	* @param options - Test webhook options
 	* @returns Promise that resolves with the test result
 	* @throws {ApiError} if the request fails
 	*/
-	async testWebhook(workspaceSlug, webhookId, options) {
-		const { data } = await this.#api.POST("/workspaces/{workspaceSlug}/webhooks/{webhookId}/test/", {
+	async testWebhook(workspaceId, webhookId, options) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/webhooks/{webhookId}/test/", {
 			params: { path: {
-				workspaceSlug,
+				workspaceId,
 				webhookId
 			} },
 			body: options ?? {}
@@ -2031,12 +2050,12 @@ var Workspaces = class {
 	}
 	/**
 	* Get workspace details by ID
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @returns Promise that resolves with the workspace details
 	* @throws {ApiError} if the request fails
 	*/
-	async getWorkspace(workspaceSlug) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/", { params: { path: { workspaceSlug } } });
+	async getWorkspace(workspaceId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/", { params: { path: { workspaceId } } });
 		return data;
 	}
 	/**
@@ -2051,64 +2070,64 @@ var Workspaces = class {
 	}
 	/**
 	* Update an existing workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param updates - Workspace update request
 	* @returns Promise that resolves with the updated workspace
 	* @throws {ApiError} if the request fails
 	*/
-	async updateWorkspace(workspaceSlug, updates) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/", {
-			params: { path: { workspaceSlug } },
+	async updateWorkspace(workspaceId, updates) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/", {
+			params: { path: { workspaceId } },
 			body: updates
 		});
 		return data;
 	}
 	/**
 	* Delete a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @returns Promise that resolves when the workspace is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteWorkspace(workspaceSlug) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/", { params: { path: { workspaceSlug } } });
+	async deleteWorkspace(workspaceId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/", { params: { path: { workspaceId } } });
 	}
 	/**
 	* Get notification settings for the authenticated user in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @returns Promise that resolves with the notification settings
 	* @throws {ApiError} if the request fails
 	*/
-	async getNotificationSettings(workspaceSlug) {
-		const { data } = await this.#api.GET("/workspaces/{workspaceSlug}/notifications/", { params: { path: { workspaceSlug } } });
+	async getNotificationSettings(workspaceId) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/notifications/", { params: { path: { workspaceId } } });
 		return data;
 	}
 	/**
 	* Update notification settings for the authenticated user in a workspace
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param settings - Notification settings update request
 	* @returns Promise that resolves with the updated notification settings
 	* @throws {ApiError} if the request fails
 	*/
-	async updateNotificationSettings(workspaceSlug, settings) {
-		const { data } = await this.#api.PATCH("/workspaces/{workspaceSlug}/notifications/", {
-			params: { path: { workspaceSlug } },
+	async updateNotificationSettings(workspaceId, settings) {
+		const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/notifications/", {
+			params: { path: { workspaceId } },
 			body: settings
 		});
 		return data;
 	}
 	/**
 	* Upload a workspace's avatar image
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @param avatar - Avatar image to upload
 	* @returns Promise that resolves when the avatar is uploaded
 	* @throws {ApiError} if the request fails
 	*/
-	async uploadAvatar(workspaceSlug, avatar) {
+	async uploadAvatar(workspaceId, avatar) {
 		const formData = new FormData();
 		const name = avatar instanceof File ? avatar.name : "avatar";
 		formData.append("avatar", avatar, name);
-		await this.#api.PUT("/workspaces/{workspaceSlug}/avatar/", {
-			params: { path: { workspaceSlug } },
+		await this.#api.PUT("/workspaces/{workspaceId}/avatar/", {
+			params: { path: { workspaceId } },
 			body: formData,
 			bodySerializer: (formData) => formData,
 			headers: { "Content-Type": null }
@@ -2116,15 +2135,15 @@ var Workspaces = class {
 	}
 	/**
 	* Delete a workspace's avatar image
-	* @param workspaceSlug - Workspace slug
+	* @param workspaceId - Workspace id
 	* @returns Promise that resolves when the avatar is deleted
 	* @throws {ApiError} if the request fails
 	*/
-	async deleteAvatar(workspaceSlug) {
-		await this.#api.DELETE("/workspaces/{workspaceSlug}/avatar/", { params: { path: { workspaceSlug } } });
+	async deleteAvatar(workspaceId) {
+		await this.#api.DELETE("/workspaces/{workspaceId}/avatar/", { params: { path: { workspaceId } } });
 	}
 };
 
 //#endregion
-export { Account as S, Auth as _, Redactions as a, Analytics as b, Pipelines as c, Invites as d, Files as f, Catalog as g, Chat as h, Status as i, Notifications as l, Connections as m, Webhooks as n, Providers as o, Detections as p, Syncs as r, Policies as s, Workspaces as t, Members as u, Assignments as v, Activities as x, ApiTokens as y };
-//# sourceMappingURL=services-DUixyxF2.js.map
+export { Auth as _, Status as a, Activities as b, Policies as c, Members as d, Invites as f, Capabilities as g, Connections as h, Syncs as i, Pipelines as l, Detections as m, Webhooks as n, Redactions as o, Documents as p, Threads as r, Providers as s, Workspaces as t, Notifications as u, ApiTokens as v, Account as x, Analytics as y };
+//# sourceMappingURL=services-CFFmQDgA.js.map