@listeningkit/telnyx 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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
+      (an example is provided in the Appendix below).
+
+      "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. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to 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. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by 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
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   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, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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/README.md

@@ -0,0 +1,263 @@
+<p align="center">
+  <img src="./banner.png" alt="@listeningkit/telnyx — Convex component for Telnyx" width="100%" />
+</p>
+
+# @listeningkit/telnyx (Convex Telnyx Component)
+
+> A production-ready [Convex Component](https://docs.convex.dev/components) for [Telnyx](https://telnyx.com) messaging: send SMS from a Convex action, verify Ed25519-signed webhooks, and keep every send and every event idempotent by default.
+
+[![Convex Component](https://img.shields.io/badge/Convex-Component-blue)](https://docs.convex.dev/components)
+[![npm version](https://img.shields.io/npm/v/@listeningkit/telnyx.svg)](https://www.npmjs.com/package/@listeningkit/telnyx)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+| | |
+|---|---|
+| **Provider** | [Telnyx](https://telnyx.com) messaging API (`POST /v2/messages`) |
+| **Component** | `@listeningkit/telnyx` on [npm](https://www.npmjs.com/package/@listeningkit/telnyx) |
+| **Source** | [github.com/matthewdonsemail-lab/convex-telnyx](https://github.com/matthewdonsemail-lab/convex-telnyx) |
+| **Auth model** | Your app authenticates; the component receives an `owner` string |
+| **License** | Apache-2.0 |
+
+---
+
+## Overview
+
+Talking to Telnyx from a Convex backend means handling three things well: keeping the API key off the client, verifying webhook signatures correctly against the **raw** request body, and not double-sending or double-processing when Telnyx retries.
+
+`@listeningkit/telnyx` does all three inside a Convex component:
+
+- **Secrets stay server-side.** The API key, public key, and default sender number are declared in the component's environment, so callers never pass a credential as an argument.
+- **Webhooks are verified properly.** Ed25519 verification over `<telnyx-timestamp>|<raw body>`, with a five-minute replay window.
+- **Everything is idempotent.** Sends are keyed by Telnyx message id, webhook events by Telnyx event id, so retries and replays never duplicate rows.
+- **The data model is isolated.** Messages and events live in the component's own schema partition and never pollute your app's tables.
+
+---
+
+## Convex Component Architecture
+
+This package follows the [Convex Component Specification](https://docs.convex.dev/components/authoring):
+
+```
+telnyx/
+├── banner.png             # Visual component header banner
+├── convex.config.ts       # Component definition & typed environment variables
+├── schema.ts              # Encapsulated schema (messages, webhookEvents)
+├── telnyx.ts              # Component actions, mutations, and queries
+├── client.ts              # Type-safe client wrapper for host applications
+├── test.ts                # convex-test registration helper
+├── lib/
+│   └── telnyx.ts          # Pure helpers (E.164 validation, send, Ed25519 verify)
+├── _generated/            # Generated component API bindings
+├── dist/                  # Compiled JavaScript and TypeScript declarations
+└── package.json           # Component exports, peerDependencies, and scripts
+```
+
+### 1. Sandboxed Database Isolation
+
+The component owns its schema. `messages` and `webhookEvents` live inside the component's isolated partition, so they cannot collide with your application's tables and are not visible to your app's clients.
+
+### 2. Typed Environment Injection
+
+Environment variables are declared in [`convex.config.ts`](./convex.config.ts):
+
+| Variable | Required | Purpose |
+|---|---|---|
+| `TELNYX_API_KEY` | yes | Telnyx v2 API key, sent as a bearer token |
+| `TELNYX_PUBLIC_KEY` | for webhooks | Base64 Ed25519 public key from the Telnyx portal |
+| `TELNYX_FROM_NUMBER` | yes, unless passed per call | Default E.164 sender number |
+| `TELNYX_API_BASE_URL` | no | Override the API base (defaults to `https://api.telnyx.com/v2`) |
+
+All are declared optional so installing the package never blocks codegen; actions fail with a clear error when a required one is missing.
+
+### 3. Auth Lives in Your App
+
+Convex components have no `ctx.auth`. Your app authenticates the caller and passes the resulting `owner` string, which the component uses to scope reads. This component never sees your auth provider — Clerk, Auth0, or your own session logic all work the same way.
+
+### 4. Ergonomic Client Wrapper
+
+Rather than assembling `ctx.runAction(components.telnyx.telnyx.sendSms, ...)` by hand, the package exports a typed `Telnyx` client whose constructor takes the generated `ComponentApi`, so it can never drift from the component's real signatures.
+
+---
+
+## Installation & Setup
+
+### 1. Install the package
+
+```bash
+# npm
+npm install @listeningkit/telnyx
+
+# pnpm
+pnpm add @listeningkit/telnyx
+
+# yarn
+yarn add @listeningkit/telnyx
+```
+
+*(Ensure `convex` `>=1.45.0` is installed as a peer dependency.)*
+
+### 2. Register the component
+
+```ts
+// convex/convex.config.ts
+import { defineApp } from "convex/server";
+import telnyx from "@listeningkit/telnyx/convex.config";
+
+const app = defineApp();
+app.use(telnyx);
+
+export default app;
+```
+
+### 3. Configure environment variables
+
+```bash
+npx convex env set TELNYX_API_KEY="your-telnyx-api-key"
+npx convex env set TELNYX_PUBLIC_KEY="base64-ed25519-public-key"
+npx convex env set TELNYX_FROM_NUMBER="+15550000001"
+```
+
+### 4. Regenerate types
+
+```bash
+npx convex dev --once
+```
+
+---
+
+## Usage
+
+### Send an SMS from an authenticated action
+
+```ts
+// convex/messages.ts
+import { v } from "convex/values";
+import { action } from "./_generated/server";
+import { components } from "./_generated/api";
+import { Telnyx } from "@listeningkit/telnyx";
+
+const telnyx = new Telnyx(components.telnyx);
+
+export const sendText = action({
+  args: { to: v.string(), text: v.string() },
+  handler: async (ctx, args) => {
+    // 1. Authenticate in your app — the component has no ctx.auth.
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
+
+    // 2. Send. The API key and default sender come from the component env.
+    return await telnyx.sendSms(ctx, {
+      owner: identity.subject,
+      to: args.to,
+      text: args.text,
+    });
+  },
+});
+```
+
+Numbers are validated as E.164 **before** any network call, so a malformed recipient never costs an API request.
+
+### Receive and verify webhooks
+
+```ts
+// convex/http.ts
+import { httpRouter } from "convex/server";
+import { httpAction } from "./_generated/server";
+import { components } from "./_generated/api";
+import { Telnyx } from "@listeningkit/telnyx";
+
+const telnyx = new Telnyx(components.telnyx);
+const http = httpRouter();
+
+http.route({
+  path: "/telnyx/webhook",
+  method: "POST",
+  handler: httpAction(async (ctx, request) => {
+    // Verification needs the exact bytes Telnyx signed.
+    const rawBody = await request.text();
+    const event = await telnyx.verifyWebhook(ctx, {
+      rawBody,
+      headers: Object.fromEntries(request.headers.entries()),
+    });
+
+    if (!event) return new Response("invalid Telnyx signature", { status: 401 });
+    if (event.event_type === "message.received") {
+      // event.payload carries id, direction, from, to, and text.
+      console.log("inbound SMS", event.payload);
+    }
+    return Response.json({ ok: true });
+  }),
+});
+
+export default http;
+```
+
+`verifyWebhook` returns `null` — never throws — for a bad signature, a stale timestamp, or an unparseable body, so you can answer `401` and let Telnyx retry. Verified events are recorded once, keyed by Telnyx event id.
+
+### Read the component's records
+
+```ts
+import { query } from "./_generated/server";
+import { components } from "./_generated/api";
+import { Telnyx } from "@listeningkit/telnyx";
+
+const telnyx = new Telnyx(components.telnyx);
+
+export const recentMessages = query({
+  args: {},
+  handler: async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
+    return await telnyx.listMessages(ctx, { owner: identity.subject, limit: 20 });
+  },
+});
+```
+
+---
+
+## Production Guardrails
+
+| Guardrail | Mechanism | Benefit |
+|---|---|---|
+| **Server-side secrets** | Component `env` only | The API key is never a function argument, so it cannot leak through client calls or logs |
+| **E.164 validation** | `lib/telnyx.ts` before fetch | Invalid numbers fail locally instead of burning an API request |
+| **Signature verification** | Ed25519 over `<timestamp>\|<raw body>` | Forged or modified webhooks are rejected |
+| **Replay window** | Five-minute timestamp tolerance | A captured webhook cannot be replayed later |
+| **Idempotent sends** | `messages` indexed by `providerMessageId` | A retried send never double-logs |
+| **Idempotent events** | `webhookEvents` indexed by `eventId` | Telnyx retries are free no-ops |
+| **Bounded upstream** | `AbortSignal.timeout(15_000)` | A hung Telnyx call cannot consume the action budget |
+
+---
+
+## Component Development & Publishing
+
+```bash
+# install
+pnpm install
+
+# generate component bindings (run before building so dist/ is not scanned)
+pnpm run build:codegen
+
+# compile declarations and JavaScript
+pnpm run build
+
+# type check and test
+pnpm run typecheck
+pnpm test
+```
+
+> **Note:** run `build:codegen` before `build`. Convex scans the component directory for modules, so a stale `dist/` would be analyzed as if it were source.
+
+### Testing your integration with `convex-test`
+
+```ts
+import { convexTest } from "convex-test";
+import { modules } from "@listeningkit/telnyx/test";
+import schema from "./schema.js";
+```
+
+---
+
+## License
+
+Apache 2.0

package/client.ts

@@ -0,0 +1,98 @@
+import type { GenericActionCtx, GenericQueryCtx } from "convex/server";
+import type { ComponentApi } from "./_generated/component.js";
+
+export type TelnyxMessageRow = {
+  _id: string;
+  _creationTime: number;
+  owner: string;
+  providerMessageId: string;
+  to: string;
+  text: string;
+  status: string;
+  createdAt: number;
+};
+
+export type TelnyxWebhookEventRow = {
+  _id: string;
+  _creationTime: number;
+  eventId: string;
+  eventType: string;
+  payload: unknown;
+  occurredAt?: string;
+  receivedAt: number;
+};
+
+export type TelnyxWebhookEvent = {
+  id: string;
+  event_type: string;
+  occurred_at?: string;
+  payload: unknown;
+};
+
+export type TelnyxSendResult = { id: string; status: string };
+
+/**
+ * The component API as seen by a host application.
+ *
+ * Aliased to the generated `ComponentApi` so the client can never drift from
+ * the component's real function signatures.
+ */
+export type TelnyxComponentApi = ComponentApi<"telnyx">;
+
+export interface TelnyxSendArgs {
+  /**
+   * Owner identifier from your host application (e.g. Clerk `identity.subject`).
+   * Used to scope the component's internal `messages` table to a tenant.
+   */
+  owner: string;
+  /**
+   * Sender number in E.164 format. Defaults to the component's `TELNYX_FROM_NUMBER`.
+   */
+  from?: string;
+  /** Recipient number in E.164 format. */
+  to: string;
+  /** Message body. Must be non-empty after trimming. */
+  text: string;
+  /** Optional per-message status callback URL. */
+  webhookUrl?: string;
+}
+
+export interface TelnyxVerifyWebhookArgs {
+  /** Raw, unparsed request body exactly as received from Telnyx. */
+  rawBody: string;
+  /** Lower-cased request headers, including `telnyx-signature-ed25519` and `telnyx-timestamp`. */
+  headers: Record<string, string>;
+}
+
+export class Telnyx {
+  constructor(public readonly component: TelnyxComponentApi) {}
+
+  /**
+   * Send an SMS through `POST /v2/messages`, then record it in the component's
+   * isolated `messages` table keyed by the Telnyx message id.
+   */
+  sendSms(ctx: { runAction: GenericActionCtx<any>["runAction"] }, args: TelnyxSendArgs) {
+    return ctx.runAction(this.component.telnyx.sendSms, args) as Promise<TelnyxSendResult>;
+  }
+
+  /**
+   * Verify an Ed25519-signed Telnyx webhook against the raw body and record the
+   * event once. Returns `null` when the signature is invalid or replayed.
+   */
+  verifyWebhook(ctx: { runAction: GenericActionCtx<any>["runAction"] }, args: TelnyxVerifyWebhookArgs) {
+    return ctx.runAction(this.component.telnyx.verifyWebhook, args) as Promise<TelnyxWebhookEvent | null>;
+  }
+
+  /** List the most recent messages recorded for an owner. */
+  listMessages(
+    ctx: { runQuery: GenericQueryCtx<any>["runQuery"] },
+    args: { owner: string; limit?: number },
+  ) {
+    return ctx.runQuery(this.component.telnyx.listMessages, args) as Promise<TelnyxMessageRow[]>;
+  }
+
+  /** List the most recently received webhook events. */
+  listWebhookEvents(ctx: { runQuery: GenericQueryCtx<any>["runQuery"] }, args: { limit?: number } = {}) {
+    return ctx.runQuery(this.component.telnyx.listWebhookEvents, args) as Promise<TelnyxWebhookEventRow[]>;
+  }
+}

package/convex.config.ts

@@ -0,0 +1,11 @@
+import { defineComponent } from "convex/server";
+import { v } from "convex/values";
+
+export default defineComponent("telnyx", {
+  env: {
+    TELNYX_API_KEY: v.optional(v.string()),
+    TELNYX_PUBLIC_KEY: v.optional(v.string()),
+    TELNYX_FROM_NUMBER: v.optional(v.string()),
+    TELNYX_API_BASE_URL: v.optional(v.string()),
+  },
+});

package/dist/_generated/api.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type * as client from "../client.js";
+import type * as lib_telnyx from "../lib/telnyx.js";
+import type * as telnyx from "../telnyx.js";
+import type * as test from "../test.js";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+declare const fullApi: ApiFromModules<{
+    client: typeof client;
+    "lib/telnyx": typeof lib_telnyx;
+    telnyx: typeof telnyx;
+    test: typeof test;
+}>;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<typeof fullApi, FunctionReference<any, "public">>;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">>;
+export declare const components: {};
+export {};
+//# sourceMappingURL=api.d.ts.map

package/dist/_generated/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../_generated/api.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,MAAM,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,KAAK,UAAU,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,KAAK,MAAM,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,KAAK,IAAI,MAAM,YAAY,CAAC;AAExC,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EACT,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAGvB,QAAA,MAAM,OAAO,EAAE,cAAc,CAAC;IAC5B,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,YAAY,EAAE,OAAO,UAAU,CAAC;IAChC,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,IAAI,EAAE,OAAO,IAAI,CAAC;CACnB,CAAiB,CAAC;AAEnB;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,EAAE,SAAS,CACzB,OAAO,OAAO,EACd,iBAAiB,CAAC,GAAG,EAAE,QAAQ,CAAC,CACjB,CAAC;AAElB;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,SAAS,CAC9B,OAAO,OAAO,EACd,iBAAiB,CAAC,GAAG,EAAE,UAAU,CAAC,CACnB,CAAC;AAElB,eAAO,MAAM,UAAU,EAAqC,EAAE,CAAC"}

package/dist/_generated/api.js

@@ -0,0 +1,31 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { anyApi, componentsGeneric } from "convex/server";
+const fullApi = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal = anyApi;
+export const components = componentsGeneric();
+//# sourceMappingURL=api.js.map

package/dist/_generated/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../_generated/api.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB;;;;;;;GAOG;AAYH,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,OAAO,GAKR,MAAa,CAAC;AAEnB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,GAAG,GAGZ,MAAa,CAAC;AAElB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAGjB,MAAa,CAAC;AAElB,MAAM,CAAC,MAAM,UAAU,GAAG,iBAAiB,EAAmB,CAAC"}