@doist/comms-sdk 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Doist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# Comms SDK (TypeScript)
+
+The official TypeScript SDK for the Comms REST API.
+
+## Installation
+
+```bash
+npm install @doist/comms-sdk
+```
+
+## Usage
+
+```typescript
+import { CommsApi } from '@doist/comms-sdk'
+
+const api = new CommsApi('YOUR_API_TOKEN')
+
+api.users
+    .getSessionUser()
+    .then((user) => console.log(user))
+    .catch((error) => console.log(error))
+```
+
+By default the SDK targets production at `https://comms.todoist.com`.
+Pass a `baseUrl` option to point at a different deployment — staging
+lives at `https://comms.staging.todoist.com`:
+
+```typescript
+const api = new CommsApi('YOUR_API_TOKEN', {
+    baseUrl: 'https://comms.staging.todoist.com',
+})
+```
+
+### Creating entities
+
+Channel / thread / comment / conversation / message / group IDs are
+opaque base58-encoded UUIDv7 strings; `workspaceId` and `userId` are
+numeric.
+
+Creation endpoints (`createChannel`, `createThread`, `createComment`,
+`getOrCreateConversation`, `createMessage`, `createGroup`) accept an
+optional `id`. **A caller-supplied `id` must be a base58-encoded
+UUIDv7** — anything else fails fast with a `UuidV7Error` before the
+request leaves the SDK. Either mint your own with `generateId()` (handy
+for optimistic UI — the ID survives the round-trip unchanged) or omit
+`id` and let the SDK mint one:
+
+```typescript
+import { CommsApi, generateId } from '@doist/comms-sdk'
+
+const api = new CommsApi('YOUR_API_TOKEN')
+
+// Option 1: let the SDK mint an ID
+const channel = await api.channels.createChannel({
+    workspaceId: 1,
+    name: 'Engineering',
+})
+
+// Option 2: mint the ID yourself (must be a base58 UUIDv7 from generateId)
+const id = generateId()
+const sameChannel = await api.channels.createChannel({
+    workspaceId: 1,
+    name: 'Engineering',
+    id,
+})
+```
+
+### Broadcast group markers
+
+Use the string constants `EVERYONE` / `EVERYONE_IN_THREAD` when
+populating `groups[]` / `directGroupMentions[]` directly, or pass
+`notifyAudience` to `createComment` / `closeThread` / `reopenThread`
+and let the SDK encode it for you:
+
+```typescript
+await api.comments.createComment({
+    threadId,
+    content: 'Heads up everyone',
+    notifyAudience: 'channel', // encoded as EVERYONE
+})
+```
+
+### OAuth 2.0
+
+```typescript
+import { getAuthorizationUrl, getAuthToken, CommsApi } from '@doist/comms-sdk'
+
+const authUrl = getAuthorizationUrl(
+    'your-client-id',
+    ['user:read', 'channels:read'],
+    'state-parameter',
+    'https://yourapp.com/callback',
+)
+
+const tokenResponse = await getAuthToken({
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    code: 'authorization-code',
+    redirectUri: 'https://yourapp.com/callback',
+})
+
+const api = new CommsApi(tokenResponse.accessToken)
+const user = await api.users.getSessionUser()
+```
+
+### Short-lived processes (CLIs, scripts)
+
+On Node, the SDK keeps a connection pool alive across requests so HTTP/2
+multiplexing and TLS reuse actually work. Long-running processes don't
+need to think about it. **Short-lived processes should `await api.close()`
+before exit**, otherwise Node's event loop waits ~4 seconds for idle
+sockets to time out:
+
+```typescript
+const api = new CommsApi('YOUR_API_TOKEN')
+try {
+    await api.users.getSessionUser()
+} finally {
+    await api.close()
+}
+```
+
+`api.close()` drains the process-global pool, so it also covers code
+paths that only use the standalone OAuth helpers (`getAuthToken`,
+`revokeAuthToken`, `registerClient`). Those flows can also import
+`closeDefaultDispatcher` directly.
+
+## Development
+
+- `npm install`
+- `npm test` — Vitest
+- `npm run type-check` — TypeScript
+- `npm run check` — oxlint + oxfmt
+- `npm run build` — emit CJS + ESM + d.ts
+
+## Releases
+
+The package follows semantic versioning; releases publish to npm via the
+GitHub workflow.
+
+## Feedback
+
+Open issues at https://github.com/Doist/comms-sdk-typescript.

package/dist/cjs/authentication.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_ENDPOINT_AUTH_METHODS = exports.COMMS_SCOPES = void 0;
+exports.getAuthStateParameter = getAuthStateParameter;
+exports.getAuthorizationUrl = getAuthorizationUrl;
+exports.getAuthToken = getAuthToken;
+exports.revokeAuthToken = revokeAuthToken;
+exports.registerClient = registerClient;
+const uuid_1 = require("uuid");
+const http_client_1 = require("./transport/http-client");
+const errors_1 = require("./types/errors");
+/**
+ * OAuth scopes for the Comms API.
+ *
+ * @remarks
+ * Request only the scopes your application needs:
+ *
+ * **User Scopes:**
+ * - `user:read` - Access user's personal settings
+ * - `user:write` - Access and update user's personal settings
+ *
+ * **Workspace Scopes:**
+ * - `workspaces:read` - Access teams the user is part of
+ * - `workspaces:write` - Access and update teams the user is part of
+ *
+ * **Channel Scopes:**
+ * - `channels:read` - Access channels
+ * - `channels:write` - Access and update channels
+ * - `channels:remove` - Access, update, and delete channels
+ *
+ * **Thread Scopes:**
+ * - `threads:read` - Access threads
+ * - `threads:write` - Access and update threads
+ * - `threads:remove` - Access, update, and delete threads
+ *
+ * **Comment Scopes:**
+ * - `comments:read` - Access comments
+ * - `comments:write` - Access and update comments
+ * - `comments:remove` - Access, update, and delete comments
+ *
+ * **Group Scopes:**
+ * - `groups:read` - Access groups
+ * - `groups:write` - Access and update groups
+ * - `groups:remove` - Access, update, and delete groups
+ *
+ * **Message Scopes:**
+ * - `messages:read` - Access messages
+ * - `messages:write` - Access and update messages
+ * - `messages:remove` - Access, update, and delete messages
+ *
+ * **Reaction Scopes:**
+ * - `reactions:read` - Access reactions
+ * - `reactions:write` - Access and update reactions
+ * - `reactions:remove` - Access, update, and delete reactions
+ *
+ * **Search Scopes:**
+ * - `search:read` - Search
+ *
+ * **Attachment Scopes:**
+ * - `attachments:read` - Access attachments
+ * - `attachments:write` - Access and update attachments
+ *
+ * **Notification Scopes:**
+ * - `notifications:read` - Read user's notifications settings
+ * - `notifications:write` - Read and update user's notifications settings
+ */
+exports.COMMS_SCOPES = [
+    'user:read',
+    'user:write',
+    'workspaces:read',
+    'workspaces:write',
+    'channels:read',
+    'channels:write',
+    'channels:remove',
+    'threads:read',
+    'threads:write',
+    'threads:remove',
+    'comments:read',
+    'comments:write',
+    'comments:remove',
+    'groups:read',
+    'groups:write',
+    'groups:remove',
+    'messages:read',
+    'messages:write',
+    'messages:remove',
+    'reactions:read',
+    'reactions:write',
+    'reactions:remove',
+    'search:read',
+    'attachments:read',
+    'attachments:write',
+    'notifications:read',
+    'notifications:write',
+];
+/** Supported token endpoint authentication methods for dynamic client registration. */
+exports.TOKEN_ENDPOINT_AUTH_METHODS = [
+    'client_secret_post',
+    'client_secret_basic',
+    'none',
+];
+function getAuthStateParameter() {
+    return (0, uuid_1.v4)();
+}
+/**
+ * Generates the authorization URL for the OAuth2 flow.
+ *
+ * The `clientId` can be either a traditional client ID string (e.g. from
+ * {@link registerClient}) or an HTTPS URL pointing to a client metadata document,
+ * as defined in {@link https://drafts.ietf.org/doc/draft-ietf-oauth-client-id-metadata-document/ RFC draft-ietf-oauth-client-id-metadata-document}.
+ */
+function getAuthorizationUrl(clientId, scopes, state, redirectUri, baseUrl) {
+    if (!scopes?.length) {
+        throw new Error('At least one scope value is required.');
+    }
+    const authBaseUrl = baseUrl ? `${baseUrl}/oauth` : 'https://comms.todoist.com/oauth';
+    const scope = scopes.join(' ');
+    const params = new URLSearchParams({
+        client_id: clientId,
+        response_type: 'code',
+        scope,
+        state,
+    });
+    if (redirectUri) {
+        params.append('redirect_uri', redirectUri);
+    }
+    return `${authBaseUrl}/authorize?${params.toString()}`;
+}
+async function getAuthToken(args, options) {
+    const tokenUrl = options?.baseUrl
+        ? `${options.baseUrl}/oauth/token`
+        : 'https://comms.todoist.com/oauth/token';
+    const payload = {
+        clientId: args.clientId,
+        clientSecret: args.clientSecret,
+        code: args.code,
+        grantType: 'authorization_code',
+        ...(args.redirectUri && { redirectUri: args.redirectUri }),
+    };
+    const response = await (0, http_client_1.request)({
+        httpMethod: 'POST',
+        baseUri: tokenUrl,
+        relativePath: '',
+        payload,
+        customFetch: options?.customFetch,
+    });
+    if (!(0, http_client_1.isSuccess)(response) || !response.data?.accessToken) {
+        throw new errors_1.CommsRequestError('Authentication token exchange failed.', response.status, response.data);
+    }
+    return response.data;
+}
+async function revokeAuthToken(args, options) {
+    const revokeUrl = options?.baseUrl
+        ? `${options.baseUrl}/oauth/revoke`
+        : 'https://comms.todoist.com/oauth/revoke';
+    const response = await (0, http_client_1.request)({
+        httpMethod: 'POST',
+        baseUri: revokeUrl,
+        relativePath: '',
+        payload: {
+            clientId: args.clientId,
+            clientSecret: args.clientSecret,
+            token: args.accessToken,
+        },
+        customFetch: options?.customFetch,
+    });
+    return (0, http_client_1.isSuccess)(response);
+}
+/**
+ * Registers a new OAuth client via Dynamic Client Registration (RFC 7591).
+ *
+ * @example
+ * ```typescript
+ * const client = await registerClient({
+ *   redirectUris: ['https://example.com/callback'],
+ *   clientName: 'My App',
+ *   scope: ['user:read', 'channels:read'],
+ * })
+ * // Use client.clientId and client.clientSecret for OAuth flows
+ * ```
+ *
+ * @returns The registered client details
+ * @throws {@link CommsRequestError} If the registration fails
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7591 RFC 7591}
+ */
+async function registerClient(args, options) {
+    const registerUrl = options?.baseUrl
+        ? `${options.baseUrl}/oauth/register`
+        : 'https://comms.todoist.com/oauth/register';
+    const response = await (0, http_client_1.request)({
+        httpMethod: 'POST',
+        baseUri: registerUrl,
+        relativePath: '',
+        payload: { ...args, scope: args.scope?.join(' ') },
+        customFetch: options?.customFetch,
+    });
+    if (!(0, http_client_1.isSuccess)(response) || !response.data?.clientId) {
+        throw new errors_1.CommsRequestError('Dynamic client registration failed.', response.status, response.data);
+    }
+    const { clientIdIssuedAt, clientSecretExpiresAt, scope, ...rest } = response.data;
+    return {
+        ...rest,
+        scope: scope ? scope.split(' ') : undefined,
+        clientIdIssuedAt: clientIdIssuedAt !== undefined ? new Date(clientIdIssuedAt * 1000) : undefined,
+        clientSecretExpiresAt: clientSecretExpiresAt === undefined
+            ? undefined
+            : clientSecretExpiresAt === 0
+                ? null
+                : new Date(clientSecretExpiresAt * 1000),
+    };
+}

package/dist/cjs/clients/add-comment-helper.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommentRequest = addCommentRequest;
+const endpoints_1 = require("../consts/endpoints");
+const http_client_1 = require("../transport/http-client");
+const entities_1 = require("../types/entities");
+const enums_1 = require("../types/enums");
+const uuidv7_1 = require("../utils/uuidv7");
+const SENTINEL_GROUP_IDS = new Set(Object.values(enums_1.NOTIFY_AUDIENCE_GROUP_IDS));
+function isNotifyAudience(value) {
+    return typeof value === 'string' && enums_1.NOTIFY_AUDIENCES.includes(value);
+}
+function collectMarkerOffenses(field, values) {
+    if (!values)
+        return null;
+    const offending = values.filter((id) => SENTINEL_GROUP_IDS.has(id));
+    return offending.length > 0 ? { field, offending } : null;
+}
+function applyNotifyAudience(params) {
+    const offenses = [
+        collectMarkerOffenses('groups', params.groups ?? undefined),
+        collectMarkerOffenses('directGroupMentions', params.directGroupMentions ?? undefined),
+    ].filter((o) => o !== null);
+    if (offenses.length > 0) {
+        const details = offenses
+            .map(({ field, offending }) => `\`${field}\` contains ${offending.join(', ')}`)
+            .join('; ');
+        throw new Error(`Reserved broadcast marker IDs found: ${details}. Pass these via \`notifyAudience\` on createComment / closeThread / reopenThread (e.g. \`notifyAudience: 'channel'\` for EVERYONE) instead of populating \`groups\` / \`directGroupMentions\` directly.`);
+    }
+    if (params.notifyAudience == null)
+        return params;
+    if (!isNotifyAudience(params.notifyAudience)) {
+        throw new Error(`Invalid \`notifyAudience\` value "${String(params.notifyAudience)}". Expected one of: ${enums_1.NOTIFY_AUDIENCES.join(', ')}.`);
+    }
+    const sentinel = enums_1.NOTIFY_AUDIENCE_GROUP_IDS[params.notifyAudience];
+    const { notifyAudience: _stripped, groups, ...rest } = params;
+    return { ...rest, groups: [...(groups ?? []), sentinel] };
+}
+function addCommentRequest(context, params, options) {
+    const normalized = applyNotifyAudience(params);
+    const withId = { ...normalized, id: (0, uuidv7_1.resolveCreateId)(normalized.id) };
+    const payload = options?.threadAction
+        ? { ...withId, threadAction: options.threadAction }
+        : withId;
+    return (0, http_client_1.request)({
+        httpMethod: 'POST',
+        baseUri: context.baseUri,
+        relativePath: `${endpoints_1.ENDPOINT_COMMENTS}/add`,
+        apiToken: context.apiToken,
+        payload,
+        customFetch: context.customFetch,
+    }).then((response) => entities_1.CommentSchema.parse(response.data));
+}

package/dist/cjs/clients/base-client.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = void 0;
+const endpoints_1 = require("../consts/endpoints");
+/**
+ * Base class for every Comms API client. Centralizes URL handling and
+ * config so individual clients stay focused on their endpoints.
+ */
+class BaseClient {
+    constructor(config) {
+        this.apiToken = config.apiToken;
+        this.baseUrl = config.baseUrl;
+        this.customFetch = config.customFetch;
+    }
+    /**
+     * Returns the base URI for an API request, with a guaranteed trailing
+     * slash so relative paths resolve cleanly through `URL`.
+     */
+    getBaseUri() {
+        if (this.baseUrl) {
+            const normalizedBaseUrl = this.baseUrl.endsWith('/') ? this.baseUrl : `${this.baseUrl}/`;
+            return `${normalizedBaseUrl}api/v1/`;
+        }
+        return (0, endpoints_1.getCommsBaseUri)();
+    }
+}
+exports.BaseClient = BaseClient;

package/dist/cjs/clients/channels-client.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsClient = exports.ChannelListSchema = void 0;
+const zod_1 = require("zod");
+const endpoints_1 = require("../consts/endpoints");
+const http_client_1 = require("../transport/http-client");
+const entities_1 = require("../types/entities");
+const uuidv7_1 = require("../utils/uuidv7");
+const base_client_1 = require("./base-client");
+exports.ChannelListSchema = zod_1.z.array(entities_1.ChannelSchema);
+/**
+ * Client for `/api/v1/channels/`. The SDK auto-generates an `id` on
+ * `createChannel` when the caller doesn't supply one — pass your own `id`
+ * to keep an optimistic-UI ID stable through the round-trip.
+ */
+class ChannelsClient extends base_client_1.BaseClient {
+    /** Lists channels in a workspace. */
+    getChannels(args) {
+        return (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${endpoints_1.ENDPOINT_CHANNELS}/get`,
+            apiToken: this.apiToken,
+            payload: args,
+            customFetch: this.customFetch,
+        }).then((response) => exports.ChannelListSchema.parse(response.data));
+    }
+    /** Fetches a single channel by ID. */
+    getChannel(id) {
+        return this.simple('GET', 'getone', { id }, entities_1.ChannelSchema);
+    }
+    /** Creates a new channel. `id` is auto-generated if not supplied. */
+    createChannel(args) {
+        return this.simple('POST', 'add', { ...args, id: (0, uuidv7_1.resolveCreateId)(args.id) }, entities_1.ChannelSchema);
+    }
+    /** Partial update of an existing channel. */
+    updateChannel(args) {
+        return this.simple('POST', 'update', { ...args }, entities_1.ChannelSchema);
+    }
+    /** Updates the channel's view filter (`only_open` / `all` / `only_closed`). */
+    updateFilters(args) {
+        return this.simple('POST', 'update_filters', { ...args }, entities_1.StatusOkSchema);
+    }
+    /** Permanently deletes a channel. */
+    deleteChannel(id) {
+        return this.simple('POST', 'remove', { id }, entities_1.StatusOkSchema);
+    }
+    archiveChannel(id) {
+        return this.simple('POST', 'archive', { id }, entities_1.StatusOkSchema);
+    }
+    unarchiveChannel(id) {
+        return this.simple('POST', 'unarchive', { id }, entities_1.StatusOkSchema);
+    }
+    favoriteChannel(id) {
+        return this.simple('POST', 'favorite', { id }, entities_1.StatusOkSchema);
+    }
+    unfavoriteChannel(id) {
+        return this.simple('POST', 'unfavorite', { id }, entities_1.StatusOkSchema);
+    }
+    addUser(args) {
+        return this.simple('POST', 'add_user', { ...args }, entities_1.ChannelSchema);
+    }
+    addUsers(args) {
+        return this.simple('POST', 'add_users', { ...args }, entities_1.ChannelSchema);
+    }
+    removeUser(args) {
+        return this.simple('POST', 'remove_user', { ...args }, entities_1.ChannelSchema);
+    }
+    removeUsers(args) {
+        return this.simple('POST', 'remove_users', { ...args }, entities_1.ChannelSchema);
+    }
+    simple(httpMethod, suffix, params, schema) {
+        return (0, http_client_1.request)({
+            httpMethod,
+            baseUri: this.getBaseUri(),
+            relativePath: `${endpoints_1.ENDPOINT_CHANNELS}/${suffix}`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+}
+exports.ChannelsClient = ChannelsClient;

package/dist/cjs/clients/comments-client.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentsClient = exports.CommentListSchema = void 0;
+const zod_1 = require("zod");
+const endpoints_1 = require("../consts/endpoints");
+const http_client_1 = require("../transport/http-client");
+const entities_1 = require("../types/entities");
+const add_comment_helper_1 = require("./add-comment-helper");
+const base_client_1 = require("./base-client");
+exports.CommentListSchema = zod_1.z.array(entities_1.CommentSchema);
+/**
+ * Client for `/api/v1/comments/`. The SDK auto-generates the comment `id`
+ * on `createComment` when the caller doesn't supply one.
+ */
+class CommentsClient extends base_client_1.BaseClient {
+    /**
+     * Lists comments in a thread. `newerThan` / `olderThan` (`Date`) are
+     * converted to `newer_than_ts` / `older_than_ts` epoch seconds on the
+     * wire.
+     */
+    getComments(args) {
+        const params = { threadId: args.threadId };
+        const newerThan = args.newerThan ?? args.from;
+        if (newerThan)
+            params.newerThanTs = Math.floor(newerThan.getTime() / 1000);
+        if (args.olderThan)
+            params.olderThanTs = Math.floor(args.olderThan.getTime() / 1000);
+        if (args.limit)
+            params.limit = args.limit;
+        return (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${endpoints_1.ENDPOINT_COMMENTS}/get`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => exports.CommentListSchema.parse(response.data));
+    }
+    /** Fetches a single comment by ID. The API wraps it in `{comment: ...}`. */
+    getComment(id) {
+        const wrappedSchema = zod_1.z.object({ comment: entities_1.CommentSchema }).transform((data) => data.comment);
+        return (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${endpoints_1.ENDPOINT_COMMENTS}/getone`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then((response) => wrappedSchema.parse(response.data));
+    }
+    /**
+     * Creates a new comment. `id` is auto-generated if not supplied.
+     */
+    createComment(args) {
+        return (0, add_comment_helper_1.addCommentRequest)({ baseUri: this.getBaseUri(), apiToken: this.apiToken, customFetch: this.customFetch }, args);
+    }
+    /** Updates a comment. */
+    updateComment(args) {
+        return (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${endpoints_1.ENDPOINT_COMMENTS}/update`,
+            apiToken: this.apiToken,
+            payload: { ...args },
+            customFetch: this.customFetch,
+        }).then((response) => entities_1.CommentSchema.parse(response.data));
+    }
+    /** Permanently deletes a comment. */
+    deleteComment(id) {
+        return (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${endpoints_1.ENDPOINT_COMMENTS}/remove`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then((response) => entities_1.StatusOkSchema.parse(response.data));
+    }
+    /**
+     * Marks the user's read position in a thread. Comment IDs are strings.
+     */
+    markPosition(args) {
+        return (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${endpoints_1.ENDPOINT_COMMENTS}/mark_position`,
+            apiToken: this.apiToken,
+            payload: { threadId: args.threadId, commentId: args.commentId },
+            customFetch: this.customFetch,
+        }).then((response) => entities_1.StatusOkSchema.parse(response.data));
+    }
+}
+exports.CommentsClient = CommentsClient;