@monok/server 1.3.0 → 1.5.0

package/AGENTS.md

@@ -0,0 +1,442 @@
+# Implementing `@monok/server` in a host application
+
+This file is a self-contained implementation contract for AI coding assistants
+and developers integrating Monok with an Express application or CMS. Follow the
+requirements below rather than inventing alternate endpoint paths or response
+shapes.
+
+## Choose the integration mode
+
+Before changing the host application, establish which mode the developer wants:
+
+1. **Content only** — implement `createMonokRouter` and publication linkbacks.
+2. **Affiliate only** — implement `monokAffiliateAttribution` and
+   `createMonokReferral`; do not expose content endpoints.
+3. **Content and affiliate** — implement both independent contracts.
+
+Do not assume affiliate functionality merely because the package supports it.
+Updating an existing content-only installation requires no affiliate code or
+configuration. Do not assume content delivery for an affiliate-only merchant.
+
+## Content integration
+
+Follow this section only for **content only** or **content and affiliate** mode.
+Expose a public HTTPS Monok content integration at these routes:
+
+- `POST /api/monok/push`
+- `GET /api/monok/info`
+- `GET /api/monok/postfilter` when article discovery is supported
+
+Use `createMonokRouter` from `@monok/server`. Mount it at `/api/monok` for the
+default API base, or at an intentional custom base such as
+`/something/specialAPI/monok`. When connecting the integration, enter either the
+site origin to select the default or the complete custom base URL. Monok appends
+`/info`, `/push`, and `/postfilter` to that base.
+
+## Content implementation
+
+Install the package and Express:
+
+```bash
+npm install @monok/server express
+```
+
+Create one router with the same secret API key configured for the Monok
+workspace:
+
+```ts
+import express from "express";
+import {
+  createMonokRouter,
+  sendMonokLinkback,
+  type MonokArticle,
+  type PostFilterQuery,
+  type PostFilterResult,
+  type SiteInfoInput
+} from "@monok/server";
+
+const app = express();
+
+app.use(
+  "/api/monok",
+  createMonokRouter({
+    apiKey: process.env.MONOK_API_KEY!,
+    imageDir: "./uploads/monok",
+    getSiteInfo: async (): Promise<SiteInfoInput> => loadSiteInfo(),
+    searchArticles: async (
+      filters: PostFilterQuery
+    ): Promise<PostFilterResult[]> => searchPublishedArticles(filters),
+    onArticle: async (article, context) => {
+      await upsertMonokArticle(article, context);
+    }
+  })
+);
+```
+
+`onArticle` and the application's persistence work are always required.
+`getSiteInfo` is optional. The router always exposes authenticated `/info`; when
+the callback is omitted it returns minimal `Custom CMS` metadata so the standard
+Monok dashboard connection and sync flow can still detect the installation.
+`searchArticles` and `imageDir` are optional; omitting article search disables
+covered-article and backlink discovery.
+
+Do not add another JSON body parser solely for these routes. The router already
+parses JSON with a 20 MB limit. A reverse proxy in front of the application must
+also permit the request size.
+
+## Receiving and storing articles
+
+`onArticle` receives:
+
+```ts
+async function onArticle(
+  article: MonokArticle,
+  context: {
+    action?: "draft" | "publish";
+    saveThumbImage(fileNameBase?: string): Promise<string | undefined>;
+  }
+): Promise<void>
+```
+
+The host must:
+
+1. Validate any application-specific constraints.
+2. Upsert by `article.id`, or enqueue an idempotent job keyed by `article.id`, so
+   repeated delivery cannot create duplicate content.
+3. Preserve `article.id` with the CMS record or queued job for later linkbacks
+   and updates.
+4. Store `article.content` as the rendered HTML body when processing the job.
+5. Apply the supplied slug, author, categories, sections, tags, language, and
+   CMS post type when the host supports them.
+6. Treat the requested action as draft unless `context.action === "publish"`.
+7. Before returning, await either durable CMS persistence or durable queue
+   acceptance. Do not acknowledge an in-memory, fire-and-forget task.
+8. Throw when persistence or durable queueing fails.
+
+The draft/publish action normally arrives in the JSON body. The package also
+supports the legacy query parameter. Do not read `article.action` directly when
+deciding publication state; use the validated `context.action` value.
+
+`onArticle` returns `void` or `Promise<void>`. It must not construct an HTTP
+response. After the callback durably saves or queues the work, the package
+returns:
+
+```json
+{
+  "ok": true,
+  "status": "accepted",
+  "monokId": "the-article-id"
+}
+```
+
+This response acknowledges delivery only. It does not promise that a draft URL,
+CMS record ID, thumbnail URL, or public canonical URL already exists. Custom CMS
+implementations may render, moderate, deploy, or publish asynchronously.
+
+Thrown errors become JSON error responses. An error with a numeric `status`
+property uses that HTTP status; other errors return `500`.
+
+## Article payload
+
+The important `MonokArticle` fields are:
+
+```ts
+interface MonokArticle {
+  id: string | number;
+  title: string;
+  shortTitle?: string;
+  description?: string;
+  content?: string;
+  text?: string;
+  slug?: string;
+  action?: "draft" | "publish";
+  author?: { id: string | number; name: string };
+  categories?: Array<{ name: string; weight?: number }>;
+  sections?: string[];
+  tags?: string[] | null;
+  language?: string;
+  type?: string;
+  thumbnail?: string;
+  thumbImageData?: string;
+  thumbAlt?: string;
+  thumbImageDescription?: string;
+  keywords?: string[];
+}
+```
+
+Treat unknown additional fields as forward-compatible metadata. Do not reject a
+payload merely because it contains fields added by a newer Monok version.
+
+## JPEG thumbnail handling
+
+Monok sends `thumbImageData` as JPEG base64. It is normally raw base64, while a
+legacy path can wrap it in `data:image/jpeg;base64,...`.
+
+When `imageDir` is configured, call `await context.saveThumbImage()` to validate
+and save it. The return value is the local `.jpg` path, or `undefined` when no
+image directory or image data was provided. The default decoded-image limit is
+15 MiB and can be changed with `maxImageBytes`.
+
+Saving a file is not the same as making it public. If the CMS has a media API or
+object storage, the host may instead process `article.thumbImageData` itself.
+Preserve `thumbAlt` or fall back to `thumbImageDescription`, then the title, for
+accessible alt text.
+
+Do not label the saved image as PNG and do not log its base64 data.
+
+## Site information
+
+Implement `getSiteInfo` when Monok should offer real CMS authors, categories,
+tags, post types, or languages. Return this shape:
+
+```ts
+const info: SiteInfoInput = {
+  js_scripts: "Enabled",
+  name: "Site name",
+  logo: "https://example.com/logo.jpg",
+  categories: ["News", "Analysis"],
+  post_types: ["post", "page"],
+  tags: ["Technology", "Business"],
+  authors: [
+    {
+      id: "author-1",
+      name: "Jane Doe",
+      profile: "Editor",
+      avatar: "https://example.com/jane.jpg",
+      roles: ["editor"]
+    }
+  ],
+  languages: {
+    en: { name: "English", slug: "en", locale: "en_US" }
+  }
+};
+```
+
+Do not return `version` from `getSiteInfo`. The router always injects the
+installed `@monok/server` package version into the `/info` response.
+
+Return empty arrays when a supported collection has no entries. Values may be
+loaded dynamically on every request. The router sends private no-cache headers.
+If `getSiteInfo` is omitted, `/info` returns this authenticated fallback:
+
+```json
+{
+  "js_scripts": "Disabled",
+  "version": "1.5.0",
+  "name": "Custom CMS",
+  "logo": "",
+  "categories": [],
+  "post_types": ["post"],
+  "tags": [],
+  "authors": []
+}
+```
+
+## Article discovery with `/postfilter`
+
+Implement `searchArticles` to expose published host content to Monok. The
+callback receives normalized values:
+
+```ts
+interface PostFilterQuery {
+  postType: string; // defaults to "post"
+  section?: string;
+  tag?: string;
+  query?: string;
+  amount: number;   // defaults to 10
+  page: number;     // defaults to 1
+}
+```
+
+Apply all supplied filters, return only published/public articles, and paginate
+deterministically. Return an array using these exact snake-case keys:
+
+```ts
+const result: PostFilterResult = {
+  canonical_url: "https://example.com/articles/example",
+  post_id: "cms-record-id",
+  title: "Example article",
+  description: "A short plain-text description"
+};
+```
+
+Return `[]` when nothing matches. `title` and `description` may be `null`.
+Do not return drafts, private content, article bodies, credentials, or internal
+metadata. If `searchArticles` is omitted, `/postfilter` returns `404`.
+
+## Authentication and cache behavior
+
+The router performs authentication. The host should not duplicate it inside
+callbacks.
+
+- `/push` accepts Monok's `token` header, `X-API-Key`, or legacy `?apikey=`.
+- `/info` and `/postfilter` accept `X-API-Key` or legacy `?apikey=`.
+- Comparisons are timing-safe.
+- `/info` and `/postfilter` responses include private no-cache headers.
+
+Keep `MONOK_API_KEY` server-side. Never expose it to browser JavaScript, commit
+it, include it in a URL shown to users, or log it. Prefer `X-API-Key` over query
+authentication for custom calls because URLs are commonly logged by proxies.
+
+## Linkback after publication
+
+When an article is actually published, notify Monok only after the public
+canonical URL exists. This applies both to a draft published later and to an
+asynchronous `action: "publish"` job:
+
+The default destination is `https://app.monok.com/api/v1/linkback`.
+`monokBaseUrl` is only an override for another Monok environment.
+
+```ts
+await sendMonokLinkback({
+  monokId: storedMonokId,
+  externalId: cmsArticleId,
+  url: canonicalUrl,
+  title,
+  thumbnailUrl: publicThumbnailUrl
+}, {
+  apiKey: process.env.MONOK_API_KEY
+});
+```
+
+Call this from the host's real publication lifecycle, not merely when `/push`
+returns or when a job enters a queue. The linkback is the authoritative signal
+that publication completed and a canonical URL exists. A retry should be safe.
+When useful, `externalId` is the stable article ID assigned by the host CMS; it
+is optional because the canonical URL also identifies the publication. When
+supplied, `thumbnailUrl` is the public thumbnail URL.
+
+## Content verification checklist
+
+Before declaring the integration complete, verify all applicable items:
+
+- `GET /api/monok/info` returns `401` without a key.
+- The same route succeeds with `X-API-Key` and with legacy `?apikey=`.
+- Info responses contain `Cache-Control: no-store`.
+- `POST /api/monok/push` accepts a body containing `action: "draft"`.
+- A body containing `action: "publish"` is durably persisted or queued with the
+  requested publication intent.
+- Successful pushes return `ok: true`, `status: "accepted"`, and the same
+  `monokId`, without requiring a canonical URL.
+- Repeating the same `article.id` updates one record instead of duplicating it.
+- Invalid action values return `400`.
+- JPEG data saves as `.jpg`, and invalid or oversized image data is rejected.
+- `/postfilter` applies search, type, section, tag, amount, and page filters.
+- `/postfilter` returns exact `canonical_url`, `post_id`, `title`, and
+  `description` fields.
+- Synchronous or asynchronous publication sends a linkback only after the public
+  canonical URL exists.
+- The integration is reachable through its production HTTPS reverse proxy.
+
+Do not claim completion based only on TypeScript compilation. Exercise the HTTP
+routes and confirm one durable draft or draft job, one publication or publication
+job, one repeated delivery, and one discovery query against the host
+application's persistence layer. For asynchronous publishing, also complete one
+job and verify its eventual linkback.
+
+## Affiliate integration
+
+Follow this section only for **affiliate only** or **content and affiliate**
+mode. A content-only installation must not be changed based on this section.
+
+For Express, mount attribution before landing, signup, authentication, and
+account-creation routes:
+
+```ts
+import express from "express";
+import {
+  createMonokReferral,
+  monokAffiliateAttribution
+} from "@monok/server";
+
+const app = express();
+
+app.use(monokAffiliateAttribution());
+app.use(express.json());
+```
+
+The middleware reads the signed `monok_ref` query parameter, stores it in an
+HttpOnly, Secure, SameSite=Lax cookie, and redirects to the same URL without the
+token. The offer controls attribution duration; cookie expiry comes from the
+token. Do not add a merchant-configured attribution duration. Only set
+`secure: false` for local HTTP development.
+
+For an apex landing site and an account application on a subdomain, explicitly
+share the cookie across the parent domain:
+
+```ts
+app.use(monokAffiliateAttribution({ cookieDomain: ".example.com" }));
+```
+
+A cookie created on `example.com` with `Domain=.example.com` is sent to
+`app.example.com`. Omit `cookieDomain` when landing and signup use the same
+hostname. Avoid simultaneous host-only and parent-domain cookies with the same
+name because they produce ambiguous duplicate cookies.
+
+After durably creating a new customer, call Monok from that same successful
+account-creation path:
+
+```ts
+if (req.monokAttribution) {
+  await createMonokReferral(
+    {
+      attributionToken: req.monokAttribution,
+      customerReference: customer.id
+    },
+    { apiKey: process.env.MONOK_API_KEY! }
+  );
+}
+```
+
+Use a durable internal customer ID for `customerReference`, never an email or
+other personal data. Do not register referrals during ordinary login,
+invitation acceptance, or flows that do not create a new merchant customer.
+Registration is idempotent for an offer/customer. A temporary Monok failure
+must not roll back an already-created customer; retain the token and customer ID
+in durable retry work. Keep `MONOK_API_KEY` server-side.
+
+Monok's own sites use this same public package and API flow. Do not replace it
+with direct database writes, an internal-only attribution service, or
+`referredWorkspaceId` handling.
+
+`monokAffiliateAttribution` is Express middleware;
+`createMonokReferral` is framework-independent server code. In another server
+framework, reproduce the capture contract server-side: read `monok_ref`, derive
+expiry from the token, set the secure HttpOnly cookie, and redirect to the clean
+URL. Then read the cookie during customer creation and pass it to
+`createMonokReferral`. A static frontend cannot create an HttpOnly cookie; it
+requires a server or CDN/edge capture handler. Client-side JavaScript cookies
+are not an equivalent secure integration.
+
+### Configure the offer on app.monok.com
+
+Briefly tell the developer to:
+
+1. Sign in to `app.monok.com` and select the merchant workspace.
+2. Open the relevant Brand and choose **Affiliate Program**.
+3. Create the offer with its exact HTTPS landing URL, commission terms,
+   duration, and attribution window.
+4. Deploy the integration, click **Test setup**, and confirm **Capture
+   verified**.
+5. Activate the offer when it is ready to receive attributed traffic.
+
+The Affiliate Program page is currently development-only. If it is absent,
+explain that it is not enabled in that environment. Do not invent another route
+or substitute the content `/info` endpoint.
+
+Affiliate integration does not require `createMonokRouter`, `/push`, `/info`,
+or `/postfilter`.
+
+### Affiliate verification checklist
+
+- Test the exact production landing URL through **Test setup**; do not fabricate
+  an attribution token locally.
+- Confirm the offer becomes **Capture verified** before activation.
+- For cross-subdomain flows, confirm the parent-domain cookie reaches the
+  account-creation hostname.
+- Exercise each qualifying customer-creation path, including credentials and
+  OAuth where applicable, and confirm it calls `createMonokReferral`.
+- Confirm login and invitation-only flows do not create referrals.
+- Do not claim end-to-end verification yet. The dashboard currently validates
+  capture only; one-time test-customer callback validation is reserved for a
+  later implementation.

package/README.md

@@ -3,7 +3,10 @@
 # `@monok/server`
 
 Monok server integration helpers for Node.js/Express.
-Easily connect your backend to Monok to receive articles, expose site info, and send linkbacks.
+Connect a backend to Monok for content delivery, affiliate attribution, or both.
+
+Using an AI coding assistant? Give it [`AGENTS.md`](./AGENTS.md). The guide contains
+the complete host-implementation contract, response shapes, and verification checklist.
 
 ---
 
@@ -16,7 +19,7 @@ import { createMonokRouter, type MonokArticle } from "@monok/server";
 const app = express();
 
 app.use(
-  "/monok",
+  "/api/monok",
   createMonokRouter({
     apiKey: process.env.MONOK_API_KEY!,
     onArticle: async (article: MonokArticle, { saveThumbImage, action }) => {
@@ -46,6 +49,52 @@ npm install @monok/server express
 
 ## 📚 Usage
 
+### Affiliate attribution (independent of content delivery)
+
+The affiliate middleware preserves the signed `monok_ref` value from a Monok
+redirect in an HttpOnly, SameSite=Lax cookie, then redirects to the same URL
+without the token. The offer controls the attribution window and the middleware
+derives the cookie expiry from the token, so merchants do not configure it.
+Mount it before the merchant's landing and signup routes. After the customer has
+been durably created, register the referral using the merchant's own stable
+customer ID.
+
+```ts
+import express from "express";
+import {
+  createMonokReferral,
+  monokAffiliateAttribution
+} from "@monok/server";
+
+const app = express();
+app.use(monokAffiliateAttribution());
+app.use(express.json());
+
+app.post("/signup", async (req, res) => {
+  const customer = await createCustomer(req.body);
+
+  if (req.monokAttribution) {
+    await createMonokReferral(
+      {
+        attributionToken: req.monokAttribution,
+        customerReference: customer.id
+      },
+      { apiKey: process.env.MONOK_API_KEY! }
+    );
+  }
+
+  res.status(201).json({ id: customer.id });
+});
+```
+
+The middleware defaults to secure cookies. For local HTTP development only, use
+`monokAffiliateAttribution({ secure: false })`. `customerReference` should be a
+durable internal ID, not an email address or other personal data. Repeating the
+same offer/customer registration is idempotent and retains the first referral.
+
+Affiliate-only merchants do **not** need to mount `createMonokRouter` or expose
+`/push`, `/info`, or `/postfilter`.
+
 ### Express setup (TypeScript)
 
 ```ts
@@ -59,19 +108,21 @@ import {
 const app = express();
 
 app.use(
-  "/monok",
+  "/api/monok",
   createMonokRouter({
     apiKey: process.env.MONOK_API_KEY!,
     imageDir: "./uploads", // optional
     // Optional: provide site info if you want Monok to query it
     getSiteInfo: {
       js_scripts: "Enabled",
-      version: "1.0.0",
       name: "My Site",
       logo: "https://example.com/logo.png",
       categories: ["Content", "News Articles", "Uncategorized"],
       post_types: ["post", "page"],
       tags: ["Tech", "Health", "News"],
+      languages: {
+        en: { name: "English", slug: "en", locale: "en_US" }
+      },
       authors: [
         {
           name: "Jane Doe",
@@ -82,6 +133,15 @@ app.use(
         }
       ]
     },
+    searchArticles: async ({ postType, section, tag, query, amount, page }) => {
+      // Search published content in your CMS and return the requested page.
+      return [{
+        canonical_url: "https://example.com/blog/an-article",
+        post_id: "cms-123",
+        title: "An article",
+        description: "Article summary"
+      }];
+    },
     onArticle: async (article: MonokArticle, { saveThumbImage, action }) => {
       const imagePath = await saveThumbImage();
       console.log("Received article:", article.title);
@@ -95,9 +155,9 @@ app.use(
       // when you publish later, notify Monok:
       // await sendMonokLinkback({
       //   monokId: article.id,
-      //   publicUrl: "https://example.com/blog/" + (article.slug ?? article.id),
+      //   externalId: savedArticle.id,
+      //   url: "https://example.com/blog/" + (article.slug ?? article.id),
       //   title: article.title,
-      //   articleTextSample: article.text?.slice(0, 500),
       //   thumbnailUrl: imagePath
       //     ? "https://example.com/uploads/" + require("path").basename(imagePath)
       //     : undefined
@@ -118,7 +178,7 @@ const { createMonokRouter } = require("@monok/server");
 const app = express();
 
 app.use(
-  "/monok",
+  "/api/monok",
   createMonokRouter({
     apiKey: process.env.MONOK_API_KEY,
     onArticle: async (article, { saveThumbImage, action }) => {
@@ -141,29 +201,58 @@ app.listen(3000);
 
 ## 🔑 Endpoints
 
-* **`POST /monok/push[?action=draft|publish]`**
+Mounting the router at `/api/monok` uses Monok's default API base. A custom or
+versioned base is also supported, for example:
+
+```ts
+app.use("/something/specialAPI/monok", createMonokRouter({ /* ... */ }));
+```
+
+Enter that complete base URL when connecting the integration in Monok. Monok
+appends `/info`, `/push`, and `/postfilter` to the configured base.
+
+* **`POST /api/monok/push`**
   Monok pushes new article data here.
   Header: `token: <your-api-key>`
   Body: JSON payload of the article.
 
-  * `action` query param may be `draft` or `publish` depending on GUI dropdown selection.
+  * `action` is read from the JSON body and may be `draft` or `publish`.
+  * A legacy `?action=draft|publish` query parameter is also accepted.
+  * After `onArticle` durably saves or queues the work, the route acknowledges
+    it with `{ "ok": true, "status": "accepted", "monokId": "..." }`. This
+    does not claim that asynchronous publication has completed.
+
+* **`GET /api/monok/info`**
+  Monok fetches this to authenticate and learn your site branding, categories, tags, and authors.
+  If `getSiteInfo` is not provided, the route remains available and returns a
+  minimal `Custom CMS` response with empty metadata collections.
 
-* **`GET /monok/info?apikey=<your-api-key>`**
-  If `getSiteInfo` is configured, Monok fetches this to learn your site branding, categories, tags, and authors.
-  If `getSiteInfo` is not provided, this route responds with `404`.
+* **`GET /api/monok/postfilter`**
+  If `searchArticles` is configured, Monok uses this route to search published
+  content. Supported parameters are `post_type`, `section`, `tag`, `q`, `amount`,
+  and `page`. If it is not configured, the route responds with `404`.
+
+`GET /info` and `GET /postfilter` accept the API key in the `X-API-Key` header
+(preferred) or the legacy `?apikey=` query parameter. Their responses include
+private no-cache headers. `POST /push` also accepts Monok's `token` header.
 
 ---
 
 ## 🔗 Linkback after publishing
 
+The push acknowledgement confirms delivery only. If publication is asynchronous,
+send the linkback later, after the public canonical URL actually exists.
+Linkbacks default to `https://app.monok.com/api/v1/linkback`; use
+`monokBaseUrl` only when targeting another Monok environment.
+
 ```ts
 import { sendMonokLinkback } from "@monok/server";
 
 await sendMonokLinkback({
   monokId: article.id,
-  publicUrl: "https://example.com/blog/" + (article.slug ?? article.id),
+  externalId: cmsArticle.id,
+  url: "https://example.com/blog/" + (article.slug ?? article.id),
   title: article.title,
-  articleTextSample: article.text?.slice(0, 500),
   thumbnailUrl: "https://example.com/uploads/" + imageFile
 });
 ```
@@ -176,8 +265,10 @@ await sendMonokLinkback({
 | ------------- | ----------------------------------------- | -------- | --------------------------------------------------------------------------------- |
 | `apiKey`      | `string`                                  | ✅        | Token Monok sends in headers / query.                                             |
 | `onArticle`   | `(article, ctx) => void \| Promise<void>` | ✅        | Handle new article pushes. `ctx` includes `saveThumbImage` and optional `action`. |
-| `getSiteInfo` | `SiteInfo \| () => SiteInfo`              | ❌        | Return site info in the Monok format. If omitted, `GET /info` responds 404.       |
-| `imageDir`    | `string`                                  | ❌        | Directory to save `thumbImageData`.                                               |
+| `getSiteInfo` | `SiteInfoInput \| () => SiteInfoInput`    | ❌        | Return host metadata; the router injects its package version. A minimal fallback is used when omitted. |
+| `searchArticles` | `(query) => PostFilterResult[]`       | ❌        | Enables authenticated article discovery through `GET /postfilter`.                |
+| `imageDir`    | `string`                                  | ❌        | Directory in which validated JPEG thumbnails are saved.                           |
+| `maxImageBytes` | `number`                               | ❌        | Maximum decoded JPEG size; defaults to 15 MiB.                                    |
 | `basePath`    | `string`                                  | ❌        | Custom prefix for routes (default "").                                            |
 
 ---

package/dist/affiliate.d.ts

@@ -0,0 +1,15 @@
+import type { RequestHandler } from "express";
+import type { MonokAffiliateAttributionOptions } from "./types.js";
+declare global {
+    namespace Express {
+        interface Request {
+            monokAttribution?: string;
+        }
+    }
+}
+/**
+ * Preserve Monok's signed redirect token in an HttpOnly cookie and expose it as
+ * `req.monokAttribution`. This does not expose any content-receiving endpoint.
+ */
+export declare function monokAffiliateAttribution(options?: MonokAffiliateAttributionOptions): RequestHandler;
+//# sourceMappingURL=affiliate.d.ts.map

package/dist/affiliate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affiliate.d.ts","sourceRoot":"","sources":["../src/affiliate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyB,cAAc,EAAY,MAAM,SAAS,CAAC;AAC/E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,YAAY,CAAC;AAcnE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,OAAO,CAAC;QAChB,UAAU,OAAO;YACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;SAC3B;KACF;CACF;AAgED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,cAAc,CAuChB"}