@molecule/api-resource-message 1.0.0

package/LICENSE

@@ -0,0 +1,115 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+
+      "Contribution" shall mean any work of authorship, including the
+      original version of the Work and any modifications or additions
+      to that Work, that is intentionally submitted to the Licensor for
+      inclusion in the Work by the copyright owner or by an individual or
+      Legal Entity authorized to submit on behalf of the copyright owner.
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      patent license to make, have made, use, offer to sell, sell, import,
+      and otherwise transfer the Work.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.
+
+   8. Limitation of Liability. In no event and under no legal theory shall
+      any Contributor be liable to You for damages.
+
+   9. Accepting Warranty or Additional Liability.
+
+   Copyright 2026 Molecule Dev, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/authorizers/index.d.ts

@@ -0,0 +1,12 @@
+export {};
+/**
+ * Message resource authorizers.
+ *
+ * Thread participation is enforced inside each handler (the authenticated
+ * user must be `participantAId` or `participantBId`). Message authorship
+ * is enforced in the service layer (`editMessage`, `deleteMessage`).
+ * No additional authorizers are required.
+ *
+ * @module
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/authorizers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/authorizers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG"}

package/dist/authorizers/index.js

@@ -0,0 +1,11 @@
+export {};
+/**
+ * Message resource authorizers.
+ *
+ * Thread participation is enforced inside each handler (the authenticated
+ * user must be `participantAId` or `participantBId`). Message authorship
+ * is enforced in the service layer (`editMessage`, `deleteMessage`).
+ * No additional authorizers are required.
+ *
+ * @module
+ */

package/dist/browser-guard.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=browser-guard.d.ts.map

package/dist/browser-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-guard.d.ts","sourceRoot":"","sources":["../src/browser-guard.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,CAAA"}

package/dist/browser-guard.js

@@ -0,0 +1,18 @@
+/**
+ * Browser guard — `@molecule/api-resource-message` is SERVER-ONLY.
+ *
+ * Generated by scripts/gen-browser-guards.mjs (workspace root) — edit THAT, not this.
+ * Evaluating a server package in a browser bundle is always an import-graph mistake
+ * (node APIs, secrets); without this guard it surfaces as a cryptic downstream crash
+ * ("Buffer is not defined") far from the culprit. Throwing here names the package and
+ * the fix at the exact moment the client bundle evaluates it. jsdom tests and SSR are
+ * unaffected: the throw requires browser globals AND the absence of a node runtime.
+ */
+const g = globalThis;
+if (g.window !== undefined && g.document !== undefined && !g.process?.versions?.node) {
+    throw new Error('@molecule/api-resource-message is SERVER-ONLY: it was bundled into browser/client code. Import it only ' +
+        'from server code (a server route/function or your API), or dynamic-import it inside ' +
+        'the server handler — never from components or shared client modules, and never ' +
+        'polyfill Buffer/process to silence this.');
+}
+export {};

package/dist/handlers/createThread.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Create / look up a 1:1 message thread.
+ *
+ * @module
+ */
+import type { MoleculeRequest, MoleculeResponse } from '@molecule/api-resource';
+/**
+ * Resolves (or lazily creates) the canonical thread between the
+ * authenticated user and a counter-participant.
+ *
+ * @param req - The request with `participantId` in body.
+ * @param res - The response object.
+ */
+export declare function createThread(req: MoleculeRequest, res: MoleculeResponse): Promise<void>;
+//# sourceMappingURL=createThread.d.ts.map

package/dist/handlers/createThread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThread.d.ts","sourceRoot":"","sources":["../../src/handlers/createThread.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAK/E;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuC7F"}

package/dist/handlers/createThread.js

@@ -0,0 +1,54 @@
+/**
+ * Create / look up a 1:1 message thread.
+ *
+ * @module
+ */
+import { t } from '@molecule/api-i18n';
+import { logger } from '@molecule/api-logger';
+import { getOrCreateThread } from '../service.js';
+import { getOrCreateThreadSchema } from '../validation.js';
+/**
+ * Resolves (or lazily creates) the canonical thread between the
+ * authenticated user and a counter-participant.
+ *
+ * @param req - The request with `participantId` in body.
+ * @param res - The response object.
+ */
+export async function createThread(req, res) {
+    const userId = res.locals.session?.userId;
+    if (!userId) {
+        res.status(401).json({
+            error: t('resource.error.unauthorized', undefined, { defaultValue: 'Unauthorized' }),
+            errorKey: 'resource.error.unauthorized',
+        });
+        return;
+    }
+    const parsed = getOrCreateThreadSchema.safeParse(req.body);
+    if (!parsed.success) {
+        const errors = parsed.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');
+        res.status(400).json({ error: errors, errorKey: 'message.error.validationFailed' });
+        return;
+    }
+    if (parsed.data.participantId === userId) {
+        res.status(400).json({
+            error: t('message.error.selfThread', undefined, {
+                defaultValue: 'Cannot start a thread with yourself',
+            }),
+            errorKey: 'message.error.selfThread',
+        });
+        return;
+    }
+    try {
+        const thread = await getOrCreateThread(userId, parsed.data.participantId);
+        res.status(201).json(thread);
+    }
+    catch (error) {
+        logger.error('Failed to create message thread', { userId, error });
+        res.status(500).json({
+            error: t('message.error.threadCreateFailed', undefined, {
+                defaultValue: 'Failed to create thread',
+            }),
+            errorKey: 'message.error.threadCreateFailed',
+        });
+    }
+}

package/dist/handlers/deleteMessage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Soft-delete a message.
+ *
+ * @module
+ */
+import type { MoleculeRequest, MoleculeResponse } from '@molecule/api-resource';
+/**
+ * Soft-deletes a message. Only the original sender may delete.
+ *
+ * @param req - The request with `messageId` URL param.
+ * @param res - The response object.
+ */
+export declare function deleteMessageHandler(req: MoleculeRequest, res: MoleculeResponse): Promise<void>;
+//# sourceMappingURL=deleteMessage.d.ts.map

package/dist/handlers/deleteMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteMessage.d.ts","sourceRoot":"","sources":["../../src/handlers/deleteMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAI/E;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,IAAI,CAAC,CA0Cf"}

package/dist/handlers/deleteMessage.js

@@ -0,0 +1,56 @@
+/**
+ * Soft-delete a message.
+ *
+ * @module
+ */
+import { t } from '@molecule/api-i18n';
+import { logger } from '@molecule/api-logger';
+import { deleteMessage } from '../service.js';
+/**
+ * Soft-deletes a message. Only the original sender may delete.
+ *
+ * @param req - The request with `messageId` URL param.
+ * @param res - The response object.
+ */
+export async function deleteMessageHandler(req, res) {
+    const userId = res.locals.session?.userId;
+    if (!userId) {
+        res.status(401).json({
+            error: t('resource.error.unauthorized', undefined, { defaultValue: 'Unauthorized' }),
+            errorKey: 'resource.error.unauthorized',
+        });
+        return;
+    }
+    const { messageId } = req.params;
+    if (!messageId) {
+        res.status(400).json({
+            error: t('message.error.missingMessageId', undefined, {
+                defaultValue: 'Message ID is required',
+            }),
+            errorKey: 'message.error.missingMessageId',
+        });
+        return;
+    }
+    try {
+        const deleted = await deleteMessage(messageId, userId);
+        if (!deleted) {
+            res.status(404).json({
+                error: t('message.error.messageNotFound', undefined, {
+                    defaultValue: 'Message not found or not deletable',
+                }),
+                errorKey: 'message.error.messageNotFound',
+            });
+            return;
+        }
+        res.status(204).end();
+    }
+    catch (error) {
+        logger.error('Failed to delete message', { messageId, userId, error });
+        res.status(500).json({
+            error: t('message.error.deleteFailed', undefined, {
+                defaultValue: 'Failed to delete message',
+            }),
+            errorKey: 'message.error.deleteFailed',
+        });
+    }
+}

package/dist/handlers/editMessage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Edit an existing message.
+ *
+ * @module
+ */
+import type { MoleculeRequest, MoleculeResponse } from '@molecule/api-resource';
+/**
+ * Edits a message body. Only the original sender may edit.
+ *
+ * @param req - The request with `messageId` URL param and `body` in body.
+ * @param res - The response object.
+ */
+export declare function editMessageHandler(req: MoleculeRequest, res: MoleculeResponse): Promise<void>;
+//# sourceMappingURL=editMessage.d.ts.map

package/dist/handlers/editMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editMessage.d.ts","sourceRoot":"","sources":["../../src/handlers/editMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAK/E;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,IAAI,CAAC,CAiDf"}

package/dist/handlers/editMessage.js

@@ -0,0 +1,63 @@
+/**
+ * Edit an existing message.
+ *
+ * @module
+ */
+import { t } from '@molecule/api-i18n';
+import { logger } from '@molecule/api-logger';
+import { editMessage } from '../service.js';
+import { editMessageSchema } from '../validation.js';
+/**
+ * Edits a message body. Only the original sender may edit.
+ *
+ * @param req - The request with `messageId` URL param and `body` in body.
+ * @param res - The response object.
+ */
+export async function editMessageHandler(req, res) {
+    const userId = res.locals.session?.userId;
+    if (!userId) {
+        res.status(401).json({
+            error: t('resource.error.unauthorized', undefined, { defaultValue: 'Unauthorized' }),
+            errorKey: 'resource.error.unauthorized',
+        });
+        return;
+    }
+    const { messageId } = req.params;
+    if (!messageId) {
+        res.status(400).json({
+            error: t('message.error.missingMessageId', undefined, {
+                defaultValue: 'Message ID is required',
+            }),
+            errorKey: 'message.error.missingMessageId',
+        });
+        return;
+    }
+    const parsed = editMessageSchema.safeParse(req.body);
+    if (!parsed.success) {
+        const errors = parsed.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');
+        res.status(400).json({ error: errors, errorKey: 'message.error.validationFailed' });
+        return;
+    }
+    try {
+        const updated = await editMessage(messageId, userId, parsed.data.body);
+        if (!updated) {
+            res.status(404).json({
+                error: t('message.error.messageNotFound', undefined, {
+                    defaultValue: 'Message not found or not editable',
+                }),
+                errorKey: 'message.error.messageNotFound',
+            });
+            return;
+        }
+        res.json(updated);
+    }
+    catch (error) {
+        logger.error('Failed to edit message', { messageId, userId, error });
+        res.status(500).json({
+            error: t('message.error.editFailed', undefined, {
+                defaultValue: 'Failed to edit message',
+            }),
+            errorKey: 'message.error.editFailed',
+        });
+    }
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,9 @@
+export * from './createThread.js';
+export * from './deleteMessage.js';
+export * from './editMessage.js';
+export * from './listThreads.js';
+export * from './markRead.js';
+export * from './messages.js';
+export * from './readThread.js';
+export * from './unreadCount.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/handlers/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}

package/dist/handlers/index.js

@@ -0,0 +1,8 @@
+export * from './createThread.js';
+export * from './deleteMessage.js';
+export * from './editMessage.js';
+export * from './listThreads.js';
+export * from './markRead.js';
+export * from './messages.js';
+export * from './readThread.js';
+export * from './unreadCount.js';

package/dist/handlers/listThreads.d.ts

@@ -0,0 +1,14 @@
+/**
+ * List threads for the authenticated user.
+ *
+ * @module
+ */
+import type { MoleculeRequest, MoleculeResponse } from '@molecule/api-resource';
+/**
+ * Returns paginated threads for the authenticated user, newest first.
+ *
+ * @param req - The request with optional `limit` / `offset` query params.
+ * @param res - The response object.
+ */
+export declare function listThreads(req: MoleculeRequest, res: MoleculeResponse): Promise<void>;
+//# sourceMappingURL=listThreads.d.ts.map

package/dist/handlers/listThreads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listThreads.d.ts","sourceRoot":"","sources":["../../src/handlers/listThreads.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAI/E;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB5F"}

package/dist/handlers/listThreads.js

@@ -0,0 +1,39 @@
+/**
+ * List threads for the authenticated user.
+ *
+ * @module
+ */
+import { t } from '@molecule/api-i18n';
+import { logger } from '@molecule/api-logger';
+import { listThreadsForParticipant } from '../service.js';
+/**
+ * Returns paginated threads for the authenticated user, newest first.
+ *
+ * @param req - The request with optional `limit` / `offset` query params.
+ * @param res - The response object.
+ */
+export async function listThreads(req, res) {
+    const userId = res.locals.session?.userId;
+    if (!userId) {
+        res.status(401).json({
+            error: t('resource.error.unauthorized', undefined, { defaultValue: 'Unauthorized' }),
+            errorKey: 'resource.error.unauthorized',
+        });
+        return;
+    }
+    const limit = parseInt(req.query.limit, 10) || 50;
+    const offset = parseInt(req.query.offset, 10) || 0;
+    try {
+        const threads = await listThreadsForParticipant(userId, { limit, offset });
+        res.json({ data: threads, limit, offset });
+    }
+    catch (error) {
+        logger.error('Failed to list threads', { userId, error });
+        res.status(500).json({
+            error: t('message.error.listThreadsFailed', undefined, {
+                defaultValue: 'Failed to list threads',
+            }),
+            errorKey: 'message.error.listThreadsFailed',
+        });
+    }
+}

package/dist/handlers/markRead.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mark a thread as read for the authenticated user.
+ *
+ * @module
+ */
+import type { MoleculeRequest, MoleculeResponse } from '@molecule/api-resource';
+/**
+ * Marks a thread as read and zeroes the authenticated user's unread
+ * counter for that thread. Broadcasts a `message:read` event over the
+ * bonded realtime provider.
+ *
+ * @param req - The request with `threadId` URL param.
+ * @param res - The response object.
+ */
+export declare function markReadHandler(req: MoleculeRequest, res: MoleculeResponse): Promise<void>;
+//# sourceMappingURL=markRead.d.ts.map

package/dist/handlers/markRead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markRead.d.ts","sourceRoot":"","sources":["../../src/handlers/markRead.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAI/E;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoDhG"}

package/dist/handlers/markRead.js

@@ -0,0 +1,68 @@
+/**
+ * Mark a thread as read for the authenticated user.
+ *
+ * @module
+ */
+import { t } from '@molecule/api-i18n';
+import { logger } from '@molecule/api-logger';
+import { markRead } from '../service.js';
+/**
+ * Marks a thread as read and zeroes the authenticated user's unread
+ * counter for that thread. Broadcasts a `message:read` event over the
+ * bonded realtime provider.
+ *
+ * @param req - The request with `threadId` URL param.
+ * @param res - The response object.
+ */
+export async function markReadHandler(req, res) {
+    const userId = res.locals.session?.userId;
+    if (!userId) {
+        res.status(401).json({
+            error: t('resource.error.unauthorized', undefined, { defaultValue: 'Unauthorized' }),
+            errorKey: 'resource.error.unauthorized',
+        });
+        return;
+    }
+    const { threadId } = req.params;
+    if (!threadId) {
+        res.status(400).json({
+            error: t('message.error.missingThreadId', undefined, {
+                defaultValue: 'Thread ID is required',
+            }),
+            errorKey: 'message.error.missingThreadId',
+        });
+        return;
+    }
+    try {
+        await markRead(threadId, userId);
+        res.status(204).end();
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        if (errorMessage.includes('not found')) {
+            res.status(404).json({
+                error: t('message.error.threadNotFound', undefined, {
+                    defaultValue: 'Thread not found',
+                }),
+                errorKey: 'message.error.threadNotFound',
+            });
+            return;
+        }
+        if (errorMessage.includes('not a participant')) {
+            res.status(403).json({
+                error: t('message.error.notParticipant', undefined, {
+                    defaultValue: 'You are not a participant in this thread',
+                }),
+                errorKey: 'message.error.notParticipant',
+            });
+            return;
+        }
+        logger.error('Failed to mark thread as read', { threadId, userId, error });
+        res.status(500).json({
+            error: t('message.error.markReadFailed', undefined, {
+                defaultValue: 'Failed to mark thread as read',
+            }),
+            errorKey: 'message.error.markReadFailed',
+        });
+    }
+}

package/dist/handlers/messages.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Send + list messages within a thread.
+ *
+ * @module
+ */
+import type { MoleculeRequest, MoleculeResponse } from '@molecule/api-resource';
+/**
+ * Lists messages in a thread, newest first.
+ *
+ * @param req - The request with `threadId` URL param and optional
+ *   `before` / `limit` query params.
+ * @param res - The response object.
+ */
+export declare function listMessagesHandler(req: MoleculeRequest, res: MoleculeResponse): Promise<void>;
+/**
+ * Sends a new message in a thread. Authenticated user must be a
+ * participant. Broadcasts a `message:sent` event when realtime is bonded.
+ *
+ * @param req - The request with `threadId` URL param and message body.
+ * @param res - The response object.
+ */
+export declare function sendMessageHandler(req: MoleculeRequest, res: MoleculeResponse): Promise<void>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/handlers/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/handlers/messages.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAK/E;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,IAAI,CAAC,CAwDf;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,IAAI,CAAC,CA2Df"}