@doist/comms-sdk 0.1.0-alpha.1

package/dist/esm/clients/threads-client.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { ENDPOINT_THREADS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { StatusOkSchema, ThreadSchema, UnreadThreadSchema, } from '../types/entities.js';
+import { resolveCreateId } from '../utils/uuidv7.js';
+import { addCommentRequest } from './add-comment-helper.js';
+import { BaseClient } from './base-client.js';
+export const ThreadListSchema = z.array(ThreadSchema);
+const GetUnreadResponseSchema = z.object({
+    data: z.array(UnreadThreadSchema),
+    version: z.number().int(),
+    inboxUnread: z.number().int().nullable().optional(),
+});
+/**
+ * Client for `/api/v1/threads/`. The SDK auto-generates the thread `id` on
+ * `createThread` when the caller doesn't supply one.
+ */
+export class ThreadsClient extends BaseClient {
+    /**
+     * Lists threads. At least one of `channelId` / `workspaceId` is required.
+     * `newerThan` / `olderThan` (`Date`) are converted to the
+     * `newer_than_ts` / `older_than_ts` epoch-second params on the wire.
+     */
+    getThreads(args) {
+        const { newerThan, olderThan, newer_than_ts, older_than_ts, ...rest } = args;
+        const resolvedNewerThan = newerThan ? Math.floor(newerThan.getTime() / 1000) : newer_than_ts;
+        const resolvedOlderThan = olderThan ? Math.floor(olderThan.getTime() / 1000) : older_than_ts;
+        const params = {
+            ...rest,
+            ...(resolvedNewerThan != null ? { newer_than_ts: resolvedNewerThan } : {}),
+            ...(resolvedOlderThan != null ? { older_than_ts: resolvedOlderThan } : {}),
+        };
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_THREADS}/get`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => ThreadListSchema.parse(response.data));
+    }
+    /** Fetches a single thread by ID. */
+    getThread(id) {
+        return this.simple('GET', 'getone', { id }, ThreadSchema);
+    }
+    /** Creates a new thread. `id` is auto-generated if not supplied. */
+    createThread(args) {
+        return this.simple('POST', 'add', { ...args, id: resolveCreateId(args.id) }, ThreadSchema);
+    }
+    /** Partial update of an existing thread. */
+    updateThread(args) {
+        return this.simple('POST', 'update', { ...args }, ThreadSchema);
+    }
+    /** Permanently deletes a thread. */
+    deleteThread(id) {
+        return this.simple('POST', 'remove', { id }, StatusOkSchema);
+    }
+    /** Saves a thread (formerly "star"). */
+    saveThread(id) {
+        return this.simple('GET', 'save', { id }, StatusOkSchema);
+    }
+    /** Unsaves a thread (formerly "unstar"). */
+    unsaveThread(id) {
+        return this.simple('GET', 'unsave', { id }, StatusOkSchema);
+    }
+    pinThread(id) {
+        return this.simple('GET', 'pin', { id }, StatusOkSchema);
+    }
+    unpinThread(id) {
+        return this.simple('GET', 'unpin', { id }, StatusOkSchema);
+    }
+    /** Moves a thread to another channel. */
+    moveToChannel(args) {
+        return this.simple('GET', 'move_to_channel', { ...args }, ThreadSchema);
+    }
+    markRead(args) {
+        return this.simple('POST', 'mark_read', { ...args }, StatusOkSchema);
+    }
+    markUnread(args) {
+        return this.simple('POST', 'mark_unread', { ...args }, StatusOkSchema);
+    }
+    markUnreadForOthers(args) {
+        return this.simple('POST', 'mark_unread_for_others', { ...args }, StatusOkSchema);
+    }
+    /**
+     * Marks every thread in a workspace or channel as read. Exactly one of
+     * `workspaceId` / `channelId` should be set.
+     */
+    markAllRead(args) {
+        if (!args.workspaceId && !args.channelId) {
+            throw new Error('Either workspaceId or channelId is required');
+        }
+        return this.simple('POST', 'mark_all_read', { ...args }, StatusOkSchema);
+    }
+    clearUnread(workspaceId) {
+        return this.simple('GET', 'clear_unread', { workspaceId }, StatusOkSchema);
+    }
+    /**
+     * Returns unread threads for a workspace, paired with the unread version
+     * counter and (optionally) the inbox unread count.
+     */
+    getUnread(workspaceId) {
+        return this.simple('GET', 'get_unread', { workspaceId }, GetUnreadResponseSchema);
+    }
+    muteThread(args) {
+        return this.simple('GET', 'mute', { ...args }, ThreadSchema);
+    }
+    unmuteThread(id) {
+        return this.simple('GET', 'unmute', { id }, ThreadSchema);
+    }
+    closeThread(args) {
+        return this.addCommentWithAction(args, 'close');
+    }
+    reopenThread(args) {
+        return this.addCommentWithAction(args, 'reopen');
+    }
+    addCommentWithAction(args, threadAction) {
+        const { id, ...rest } = args;
+        return addCommentRequest({ baseUri: this.getBaseUri(), apiToken: this.apiToken, customFetch: this.customFetch }, { threadId: id, ...rest }, { threadAction });
+    }
+    simple(httpMethod, suffix, params, schema) {
+        return request({
+            httpMethod,
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_THREADS}/${suffix}`,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+}

package/dist/esm/clients/users-client.js

@@ -0,0 +1,195 @@
+import { ENDPOINT_USERS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { UserSchema } from '../types/entities.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Client for the `/api/v1/users/` endpoints. Authentication flows through
+ * Todoist-ID; `register` / `login` / `loginWithGoogle` / `loginWithToken` /
+ * `loginWithTodoist` are the available entry points.
+ */
+export class UsersClient extends BaseClient {
+    /** Registers a new user via the Todoist-ID bridge. */
+    register(args) {
+        return this.post(`${ENDPOINT_USERS}/register`, args, UserSchema, { authed: false });
+    }
+    /** Logs in an existing user. */
+    login(args) {
+        return this.post(`${ENDPOINT_USERS}/login`, args, UserSchema, { authed: false });
+    }
+    /**
+     * Logs in using a valid token (sent via Authorization header). The SDK
+     * client is already configured with the token, so no args are needed.
+     */
+    loginWithToken() {
+        return this.post(`${ENDPOINT_USERS}/login_with_token`, undefined, UserSchema);
+    }
+    /**
+     * Exchanges the browser's Todoist web-session cookie for a Comms session.
+     * Only useful when running in a browser context on the shared Todoist
+     * registrable domain — the cookie is sent automatically by the browser.
+     */
+    loginWithTodoist() {
+        return this.post(`${ENDPOINT_USERS}/login_with_todoist`, {}, UserSchema, { authed: false });
+    }
+    /** Logs in (and auto-signs-up) via a Google ID token. */
+    loginWithGoogle(args) {
+        return this.post(`${ENDPOINT_USERS}/login_with_google`, args, UserSchema, { authed: false });
+    }
+    /**
+     * Completes an MFA challenge issued by `loginWithGoogle` (returns an MFA
+     * token to pass back to `loginWithGoogle.mfaToken`).
+     */
+    mfaChallenge(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/mfa/challenge`,
+            apiToken: undefined,
+            payload: args,
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /** Logs out the current user and clears the session cookie. */
+    logout() {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/logout`,
+            apiToken: this.apiToken,
+            payload: undefined,
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Returns the user associated with the current access token. */
+    getSessionUser() {
+        return this.get(`${ENDPOINT_USERS}/get_session_user`, undefined, UserSchema);
+    }
+    /**
+     * Fetches a single user. Defaults to the session user when no `id` is
+     * passed. Cross-workspace lookups require that the caller and the target
+     * share a workspace.
+     */
+    getUser(args) {
+        return this.get(`${ENDPOINT_USERS}/getone`, args ?? {}, UserSchema);
+    }
+    /** Looks up a user by their email address. */
+    getUserByEmail(email) {
+        return this.get(`${ENDPOINT_USERS}/get_by_email`, { email }, UserSchema);
+    }
+    /**
+     * Updates the logged-in user's profile. Most fields are proxied to
+     * Todoist (full name, password, language, timezone, etc.).
+     */
+    update(args) {
+        return this.post(`${ENDPOINT_USERS}/update`, args, UserSchema);
+    }
+    /** Updates the user's password. Requires `currentPassword`. */
+    updatePassword(args) {
+        return this.post(`${ENDPOINT_USERS}/update_password`, args, UserSchema);
+    }
+    /** Removes the user's avatar. */
+    removeAvatar() {
+        return this.post(`${ENDPOINT_USERS}/remove_avatar`, undefined, UserSchema);
+    }
+    /**
+     * Invalidates the current API token and returns the user with a fresh
+     * token.
+     */
+    invalidateToken() {
+        return this.post(`${ENDPOINT_USERS}/invalidate_token`, undefined, UserSchema);
+    }
+    /**
+     * Validates that an arbitrary token is still active. Note this is sent
+     * as a GET — the token is read from the query string, not the
+     * Authorization header.
+     */
+    validateToken(token) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/validate_token`,
+            apiToken: undefined,
+            payload: { token },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Marks the user as active on a workspace (presence beacon). */
+    heartbeat(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/heartbeat`,
+            apiToken: this.apiToken,
+            payload: args,
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Resets the user's presence for a workspace. */
+    resetPresence(workspaceId) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/reset_presence`,
+            apiToken: this.apiToken,
+            payload: { workspaceId },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Checks whether an email address is registered (and verified). */
+    checkEmail(email) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/check_email`,
+            apiToken: undefined,
+            payload: { email },
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /**
+     * Returns the current per-channel mail unsubscribe settings for the
+     * caller's primary email.
+     */
+    getUnsubscribeSettings() {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/get_unsubscribe_settings`,
+            apiToken: this.apiToken,
+            payload: undefined,
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /** Toggles per-email-type opt-out settings. */
+    updateUnsubscribeSettings(settings) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_USERS}/update_unsubscribe_settings`,
+            apiToken: this.apiToken,
+            payload: settings,
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    get(url, params, schema) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: url,
+            apiToken: this.apiToken,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+    post(url, params, schema, options = {}) {
+        const authed = options.authed ?? true;
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: url,
+            apiToken: authed ? this.apiToken : undefined,
+            payload: params,
+            customFetch: this.customFetch,
+        }).then((response) => schema.parse(response.data));
+    }
+}

package/dist/esm/clients/workspace-users-client.js

@@ -0,0 +1,136 @@
+import { request } from '../transport/http-client.js';
+import { WorkspaceUserSchema } from '../types/entities.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Client for `/api/v1/workspace_users/`. The backend's `add` endpoint
+ * rejects non-empty `name` and `channelIds` — set neither.
+ */
+export class WorkspaceUsersClient extends BaseClient {
+    /** Returns workspace user objects for the given workspace id. */
+    getWorkspaceUsers(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/get',
+            apiToken: this.apiToken,
+            payload: { id: args.workspaceId, archived: args.archived },
+            customFetch: this.customFetch,
+        }).then((response) => response.data.map((user) => WorkspaceUserSchema.parse(user)));
+    }
+    /** Returns workspace user IDs for the given workspace id. */
+    getWorkspaceUserIds(workspaceId) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/get_ids',
+            apiToken: this.apiToken,
+            payload: { id: workspaceId },
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /** Gets a user by id. */
+    getUserById(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/getone',
+            apiToken: this.apiToken,
+            payload: { id: args.workspaceId, user_id: args.userId },
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceUserSchema.parse(response.data));
+    }
+    /** Gets a user by email. */
+    getUserByEmail(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/get_by_email',
+            apiToken: this.apiToken,
+            payload: { id: args.workspaceId, email: args.email },
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceUserSchema.parse(response.data));
+    }
+    /** Gets the user's info in the context of the workspace. */
+    getUserInfo(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/get_info',
+            apiToken: this.apiToken,
+            payload: { id: args.workspaceId, user_id: args.userId },
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /** Gets the user's local time (e.g., "2017-05-10 07:55:40"). */
+    getUserLocalTime(args) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/get_local_time',
+            apiToken: this.apiToken,
+            payload: { id: args.workspaceId, user_id: args.userId },
+            customFetch: this.customFetch,
+        }).then((response) => response.data);
+    }
+    /** Adds a person to a workspace. */
+    addUser(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/add',
+            apiToken: this.apiToken,
+            payload: {
+                id: args.workspaceId,
+                email: args.email,
+                userType: args.userType,
+            },
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceUserSchema.parse(response.data));
+    }
+    /** Updates a person in a workspace. */
+    updateUser(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/update',
+            apiToken: this.apiToken,
+            payload: {
+                id: args.workspaceId,
+                userType: args.userType,
+                email: args.email,
+                userId: args.userId,
+            },
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceUserSchema.parse(response.data));
+    }
+    /** Removes a person from a workspace. */
+    removeUser(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/remove',
+            apiToken: this.apiToken,
+            payload: {
+                id: args.workspaceId,
+                email: args.email,
+                userId: args.userId,
+            },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Sends a new workspace invitation to the selected user. */
+    resendInvite(args) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: 'workspace_users/resend_invite',
+            apiToken: this.apiToken,
+            payload: {
+                id: args.workspaceId,
+                email: args.email,
+                userId: args.userId,
+            },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+}

package/dist/esm/clients/workspaces-client.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { ENDPOINT_WORKSPACES } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { ChannelSchema, WorkspaceSchema } from '../types/entities.js';
+import { BaseClient } from './base-client.js';
+export const ChannelListSchema = z.array(ChannelSchema);
+/**
+ * Client for `/api/v1/workspaces/`. Workspace IDs are integers. The backend
+ * currently rejects any `color` other than `1` on add/update.
+ */
+export class WorkspacesClient extends BaseClient {
+    /** Gets all the user's workspaces. */
+    getWorkspaces() {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_WORKSPACES}/get`,
+            apiToken: this.apiToken,
+            payload: undefined,
+            customFetch: this.customFetch,
+        }).then((response) => response.data.map((workspace) => WorkspaceSchema.parse(workspace)));
+    }
+    /** Gets a single workspace object by id. */
+    getWorkspace(id) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_WORKSPACES}/getone`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceSchema.parse(response.data));
+    }
+    /** Gets the user's default workspace. */
+    getDefaultWorkspace() {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_WORKSPACES}/get_default`,
+            apiToken: this.apiToken,
+            payload: undefined,
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceSchema.parse(response.data));
+    }
+    /** Creates a new workspace. */
+    createWorkspace(name) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_WORKSPACES}/add`,
+            apiToken: this.apiToken,
+            payload: { name },
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceSchema.parse(response.data));
+    }
+    /** Updates an existing workspace. */
+    updateWorkspace(id, name) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_WORKSPACES}/update`,
+            apiToken: this.apiToken,
+            payload: { id, name },
+            customFetch: this.customFetch,
+        }).then((response) => WorkspaceSchema.parse(response.data));
+    }
+    /** Removes a workspace and all its data (not recoverable). */
+    removeWorkspace(id) {
+        return request({
+            httpMethod: 'POST',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_WORKSPACES}/remove`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then(() => undefined);
+    }
+    /** Gets the public channels of a workspace. */
+    getPublicChannels(id) {
+        return request({
+            httpMethod: 'GET',
+            baseUri: this.getBaseUri(),
+            relativePath: `${ENDPOINT_WORKSPACES}/get_public_channels`,
+            apiToken: this.apiToken,
+            payload: { id },
+            customFetch: this.customFetch,
+        }).then((response) => ChannelListSchema.parse(response.data));
+    }
+}

package/dist/esm/comms-api.js

@@ -0,0 +1,61 @@
+import { ChannelsClient } from './clients/channels-client.js';
+import { CommentsClient } from './clients/comments-client.js';
+import { ConversationMessagesClient } from './clients/conversation-messages-client.js';
+import { ConversationsClient } from './clients/conversations-client.js';
+import { GroupsClient } from './clients/groups-client.js';
+import { InboxClient } from './clients/inbox-client.js';
+import { ReactionsClient } from './clients/reactions-client.js';
+import { SearchClient } from './clients/search-client.js';
+import { ThreadsClient } from './clients/threads-client.js';
+import { UsersClient } from './clients/users-client.js';
+import { WorkspaceUsersClient } from './clients/workspace-users-client.js';
+import { WorkspacesClient } from './clients/workspaces-client.js';
+import { closeDefaultDispatcher } from './transport/http-dispatcher.js';
+/**
+ * The main API client for interacting with the Comms REST API.
+ *
+ * @example
+ * ```typescript
+ * import { CommsApi } from '@doist/comms-sdk'
+ *
+ * const api = new CommsApi('your-api-token')
+ * const user = await api.users.getSessionUser()
+ * ```
+ */
+export class CommsApi {
+    /**
+     * Creates a new Comms API client.
+     *
+     * @param authToken - Your Comms API token.
+     * @param options - Optional configuration options.
+     */
+    constructor(authToken, options) {
+        const clientConfig = {
+            apiToken: authToken,
+            baseUrl: options?.baseUrl,
+            customFetch: options?.customFetch,
+        };
+        this.users = new UsersClient(clientConfig);
+        this.workspaces = new WorkspacesClient(clientConfig);
+        this.workspaceUsers = new WorkspaceUsersClient(clientConfig);
+        this.channels = new ChannelsClient(clientConfig);
+        this.threads = new ThreadsClient(clientConfig);
+        this.groups = new GroupsClient(clientConfig);
+        this.conversations = new ConversationsClient(clientConfig);
+        this.comments = new CommentsClient(clientConfig);
+        this.conversationMessages = new ConversationMessagesClient(clientConfig);
+        this.inbox = new InboxClient(clientConfig);
+        this.reactions = new ReactionsClient(clientConfig);
+        this.search = new SearchClient(clientConfig);
+    }
+    /**
+     * Drains the SDK's process-global connection pool. CLIs and scripts
+     * should `await api.close()` before exit so Node's event loop empties
+     * immediately instead of waiting ~4s on keep-alive. Affects every
+     * `CommsApi` and OAuth helper in the same process — it's a
+     * process-shutdown gesture, not an instance teardown. Browser-safe.
+     */
+    async close() {
+        await closeDefaultDispatcher();
+    }
+}

package/dist/esm/consts/endpoints.js

@@ -0,0 +1,23 @@
+const BASE_URI = 'https://comms.todoist.com';
+const API_VERSION = 'v1';
+/**
+ * Gets the base URI for Comms API requests.
+ *
+ * @param domainBase - Custom domain base URL. Defaults to Comms' API domain.
+ * @returns Complete base URI with trailing slash (e.g., 'https://comms.todoist.com/api/v1/')
+ */
+export function getCommsBaseUri(domainBase = BASE_URI) {
+    return new URL(`/api/${API_VERSION}/`, domainBase).toString();
+}
+export const ENDPOINT_USERS = 'users';
+export const ENDPOINT_WORKSPACES = 'workspaces';
+export const ENDPOINT_CHANNELS = 'channels';
+export const ENDPOINT_THREADS = 'threads';
+export const ENDPOINT_GROUPS = 'groups';
+export const ENDPOINT_CONVERSATIONS = 'conversations';
+export const ENDPOINT_COMMENTS = 'comments';
+export const ENDPOINT_NOTIFICATIONS = 'notifications';
+export const ENDPOINT_INBOX = 'inbox';
+export const ENDPOINT_REACTIONS = 'reactions';
+export const ENDPOINT_SEARCH = 'search';
+export const ENDPOINT_CONVERSATION_MESSAGES = 'conversation_messages';

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+export * from './authentication.js';
+export { ChannelsClient } from './clients/channels-client.js';
+export { CommentsClient } from './clients/comments-client.js';
+export { ConversationMessagesClient } from './clients/conversation-messages-client.js';
+export { ConversationsClient } from './clients/conversations-client.js';
+export { GroupsClient } from './clients/groups-client.js';
+export { InboxClient } from './clients/inbox-client.js';
+export { ReactionsClient } from './clients/reactions-client.js';
+export { SearchClient } from './clients/search-client.js';
+export { ThreadsClient } from './clients/threads-client.js';
+export { UsersClient } from './clients/users-client.js';
+export { WorkspaceUsersClient } from './clients/workspace-users-client.js';
+export { WorkspacesClient } from './clients/workspaces-client.js';
+export { CommsApi } from './comms-api.js';
+export { closeDefaultDispatcher } from './transport/http-dispatcher.js';
+export * from './types/index.js';
+export * from './utils/index.js';