@86d-app/search 0.0.3 → 0.0.6

package/.turbo/turbo-build.log

@@ -0,0 +1 @@
+$ tsc

package/AGENTS.md

@@ -0,0 +1,72 @@
+# Search Module
+
+In-memory full-text search with fuzzy matching, faceted filtering, click tracking, and query analytics.
+
+## Structure
+
+```
+src/
+  index.ts          Factory: search(options?) => Module
+  schema.ts         Data models: searchIndex, searchQuery, searchSynonym, searchClick
+  service.ts        SearchController interface + types (SearchResult, SearchFacets, SearchClick, etc.)
+  service-impl.ts   SearchController implementation (fuzzy, Levenshtein, highlights, facets)
+  store/
+    components/     Store-facing TSX (search bar, page, results)
+    endpoints/
+      store-search.ts    GET  /search/store-search (search integration)
+      search.ts          GET  /search (full-text with sort, tags, fuzzy, facets, did-you-mean)
+      suggest.ts         GET  /search/suggest
+      recent.ts          GET  /search/recent
+      click.ts           POST /search/click (click tracking)
+  admin/
+    components/     Admin TSX (analytics dashboard)
+    endpoints/
+      analytics.ts           GET  /admin/search/analytics (includes CTR + avg click position)
+      popular.ts             GET  /admin/search/popular
+      zero-results.ts        GET  /admin/search/zero-results
+      click-analytics.ts     GET  /admin/search/clicks
+      synonyms.ts            GET  /admin/search/synonyms
+                             POST /admin/search/synonyms/add
+                             POST /admin/search/synonyms/:id/delete
+      index-manage.ts        POST /admin/search/index
+                             POST /admin/search/index/remove
+      bulk-index.ts          POST /admin/search/index/bulk (up to 500 items)
+```
+
+## Options
+
+```ts
+SearchOptions {
+  maxResults?: number
+}
+```
+
+## Data models
+
+- **searchIndex**: id, entityType, entityId, title, body?, tags (json[]), url, image?, metadata (json), indexedAt
+- **searchQuery**: id, term, normalizedTerm, resultCount, sessionId?, searchedAt
+- **searchSynonym**: id, term, synonyms (json[]), createdAt
+- **searchClick**: id, queryId, term, entityType, entityId, position, clickedAt
+
+## Events
+
+- Emits: `search.queried`, `search.indexed`, `search.removed`, `search.clicked`
+
+## Patterns
+
+- Registers `search: { store: "/search/store-search" }` for cross-module search integration
+- Registers store page at `/search` (SearchPage component)
+- `indexItem` uses composite key `${entityType}_${entityId}` for deduplication; re-indexing updates in-place
+- Different entityTypes with same entityId are separate index entries
+- **Fuzzy search**: Levenshtein distance matching on title/tag/body tokens. Edit tolerance: 0 for ≤3 chars, 1 for 4-5 chars, 2 for 6+ chars. Enabled by default, disable with `fuzzy: false`
+- **Scoring**: exact title (100) > title prefix (50) > tag exact (30) > title substring (25) > fuzzy title (15) > tag substring (15) > body (10) > fuzzy tag (8) > fuzzy body (5)
+- **Sorting**: relevance (default), newest, oldest, title_asc, title_desc
+- **Facets**: search results include entityType counts and tag counts (top 20)
+- **Tag filtering**: pass `tags` option to filter results to items matching any specified tag
+- **Highlights**: results include `<mark>` wrapped text in title and body for matched terms
+- **Did-you-mean**: when a search returns zero results, suggests corrections using Levenshtein distance against indexed titles and popular search terms
+- **Click tracking**: `recordClick()` stores query-to-click data; analytics includes CTR and avg click position
+- **Bulk indexing**: `bulkIndex()` accepts up to 500 items, returns `{indexed, errors}` counts
+- `recordQuery()` logs each search for analytics (popular terms, zero-result tracking)
+- `suggest(prefix)` returns autocomplete: popular terms with results first, then matching index titles, deduplicated
+- Synonyms are bidirectional: if "tee" → ["t-shirt"], then searching "tee" or "t-shirt" finds both

package/README.md

@@ -9,18 +9,17 @@
 </p>
 
 <p align="center">
-  <a href="https://vercel.com/changelog"><strong>npm</strong></a> ·
   <a href="https://x.com/86d_app"><strong>X</strong></a> ·
-  <a href="https://vercel.com/templates"><strong>LinkedIn</strong></a>
+  <a href="https://www.linkedin.com/company/86d"><strong>LinkedIn</strong></a>
 </p>
 <br/>
 
 > [!WARNING]
 > This project is under active development and is not ready for production use. Please proceed with caution. Use at your own risk.
 
-# @86d-app/search
+# Search Module
 
-Unified search, autocomplete, and search analytics module for 86d commerce platform.
+Full-text search with fuzzy matching, faceted filtering, autocomplete, click tracking, and search analytics for 86d commerce platform.
 
 ## Installation
 
@@ -48,55 +47,128 @@ const module = search({
 
 | Method | Path | Description |
 |---|---|---|
-| `GET` | `/search?q=...&type=...&limit=...&skip=...` | Full-text search with optional entity type filtering |
-| `GET` | `/search/suggest?prefix=...&limit=...` | Autocomplete suggestions |
+| `GET` | `/search?q=...&type=...&tags=...&sort=...&fuzzy=...&limit=...&skip=...` | Full-text search with facets, sorting, fuzzy matching, and did-you-mean |
+| `GET` | `/search/suggest?q=...&limit=...` | Autocomplete suggestions |
 | `GET` | `/search/recent?sessionId=...&limit=...` | Recent search queries by session |
+| `POST` | `/search/click` | Record a search result click (queryId, term, entityType, entityId, position) |
+
+### Search query parameters
+
+| Param | Type | Default | Description |
+|---|---|---|---|
+| `q` | `string` | required | Search query text |
+| `type` | `string` | — | Filter by entity type |
+| `tags` | `string` | — | Comma-separated tag filter |
+| `sort` | `string` | `relevance` | Sort: `relevance`, `newest`, `oldest`, `title_asc`, `title_desc` |
+| `fuzzy` | `boolean` | `true` | Enable fuzzy/typo-tolerant matching |
+| `limit` | `number` | `20` | Results per page (max 100) |
+| `skip` | `number` | `0` | Offset for pagination |
+| `sessionId` | `string` | — | Session ID for analytics tracking |
+
+### Search response
+
+```ts
+{
+  results: Array<{
+    id: string;
+    entityType: string;
+    entityId: string;
+    title: string;
+    url: string;
+    image?: string;
+    tags: string[];
+    score: number;
+    highlights?: { title?: string; body?: string };
+  }>;
+  total: number;
+  facets: {
+    entityTypes: Array<{ type: string; count: number }>;
+    tags: Array<{ tag: string; count: number }>;
+  };
+  didYouMean?: string;
+}
+```
 
 ## Admin Endpoints
 
 | Method | Path | Description |
 |---|---|---|
-| `GET` | `/admin/search/analytics` | Search analytics summary |
+| `GET` | `/admin/search/analytics` | Search analytics summary (includes CTR and avg click position) |
 | `GET` | `/admin/search/popular` | Most popular search terms |
 | `GET` | `/admin/search/zero-results` | Queries that returned zero results |
+| `GET` | `/admin/search/clicks` | Click-through rate analytics |
 | `GET` | `/admin/search/synonyms` | List all synonym groups |
 | `POST` | `/admin/search/synonyms/add` | Add a synonym group |
 | `POST` | `/admin/search/synonyms/:id/delete` | Delete a synonym group |
 | `POST` | `/admin/search/index` | Manually index an item |
 | `POST` | `/admin/search/index/remove` | Remove an item from the index |
+| `POST` | `/admin/search/index/bulk` | Bulk index up to 500 items |
 
 ## Controller API
 
 ```ts
 interface SearchController {
+  // Indexing
   indexItem(params: {
     entityType: string;
     entityId: string;
     title: string;
     body?: string;
     tags?: string[];
-    url?: string;
+    url: string;
     image?: string;
     metadata?: Record<string, unknown>;
   }): Promise<SearchIndexItem>;
 
-  removeFromIndex(entityType: string, entityId: string): Promise<void>;
+  bulkIndex(items: Array<{
+    entityType: string;
+    entityId: string;
+    title: string;
+    body?: string;
+    tags?: string[];
+    url: string;
+    image?: string;
+    metadata?: Record<string, unknown>;
+  }>): Promise<{ indexed: number; errors: number }>;
+
+  removeFromIndex(entityType: string, entityId: string): Promise<boolean>;
 
+  // Search
   search(query: string, options?: {
     entityType?: string;
+    tags?: string[];
+    sort?: SearchSortField;
+    fuzzy?: boolean;
     limit?: number;
     skip?: number;
-  }): Promise<{ results: SearchResult[]; total: number }>;
+  }): Promise<{
+    results: SearchResult[];
+    total: number;
+    facets: SearchFacets;
+    didYouMean?: string;
+  }>;
 
   suggest(prefix: string, limit?: number): Promise<string[]>;
-  recordQuery(term: string, resultCount: number, sessionId?: string): Promise<void>;
+
+  // Analytics
+  recordQuery(term: string, resultCount: number, sessionId?: string): Promise<SearchQuery>;
+  recordClick(params: {
+    queryId: string;
+    term: string;
+    entityType: string;
+    entityId: string;
+    position: number;
+  }): Promise<SearchClick>;
   getRecentQueries(sessionId: string, limit?: number): Promise<SearchQuery[]>;
   getPopularTerms(limit?: number): Promise<PopularTerm[]>;
-  getZeroResultQueries(limit?: number): Promise<SearchQuery[]>;
+  getZeroResultQueries(limit?: number): Promise<PopularTerm[]>;
   getAnalytics(): Promise<SearchAnalyticsSummary>;
+
+  // Synonyms
   addSynonym(term: string, synonyms: string[]): Promise<SearchSynonym>;
-  removeSynonym(id: string): Promise<void>;
+  removeSynonym(id: string): Promise<boolean>;
   listSynonyms(): Promise<SearchSynonym[]>;
+
   getIndexCount(): Promise<number>;
 }
 ```
@@ -104,22 +176,27 @@ interface SearchController {
 ## Types
 
 ```ts
-interface SearchIndexItem {
-  id: string;
-  entityType: string;
-  entityId: string;
-  title: string;
-  body?: string;
-  tags: string[];
-  url?: string;
-  image?: string;
-  metadata?: Record<string, unknown>;
-  indexedAt: Date;
-}
+type SearchSortField = "relevance" | "newest" | "oldest" | "title_asc" | "title_desc";
 
 interface SearchResult {
   item: SearchIndexItem;
   score: number;
+  highlights?: { title?: string; body?: string };
+}
+
+interface SearchFacets {
+  entityTypes: Array<{ type: string; count: number }>;
+  tags: Array<{ tag: string; count: number }>;
+}
+
+interface SearchClick {
+  id: string;
+  queryId: string;
+  term: string;
+  entityType: string;
+  entityId: string;
+  position: number;
+  clickedAt: Date;
 }
 
 interface SearchAnalyticsSummary {
@@ -128,11 +205,76 @@ interface SearchAnalyticsSummary {
   avgResultCount: number;
   zeroResultCount: number;
   zeroResultRate: number;
+  clickThroughRate: number;
+  avgClickPosition: number;
 }
+```
 
-interface PopularTerm {
-  term: string;
-  count: number;
-  avgResultCount: number;
-}
+## Store Components
+
+### SearchBar
+
+An autocomplete search input with keyboard navigation support. Fetches suggestions as the user types (minimum 2 characters) and triggers a search callback on submission. Includes a search icon and an accessible combobox dropdown.
+
+#### Props
+
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| `placeholder` | `string` | No | Placeholder text for the search input. Defaults to `"Search..."`. |
+| `onSearch` | `(query: string) => void` | No | Callback fired when the user submits a search query (via Enter key or suggestion click). |
+
+#### Usage in MDX
+
+```mdx
+<SearchBar placeholder="Search products..." onSearch={handleSearch} />
 ```
+
+Best used in the site header or on a search page to provide instant search suggestions as customers type.
+
+### SearchPage
+
+A complete search experience combining SearchBar and SearchResults into a single page layout with a heading, search input, and results area. Manages the search query state internally.
+
+#### Props
+
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| `sessionId` | `string` | No | Optional session ID passed to SearchResults for analytics tracking. |
+
+#### Usage in MDX
+
+```mdx
+<SearchPage />
+```
+
+Best used as the main content of a dedicated `/search` page in the storefront.
+
+### SearchResults
+
+Displays search results for a given query, with loading and empty states. Fetches results from the search module and renders them as linked cards with optional images.
+
+#### Props
+
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| `query` | `string` | Yes | The search query string to execute. |
+| `entityType` | `string` | No | Filter results to a specific entity type (e.g., `"product"`). |
+| `sessionId` | `string` | No | Optional session ID for search analytics tracking. |
+| `limit` | `number` | No | Maximum number of results to return. Defaults to `20`. |
+
+#### Usage in MDX
+
+```mdx
+<SearchResults query="shoes" entityType="product" limit={10} />
+```
+
+Best used below a search bar to display results, or on a category page for filtered search results.
+
+## Notes
+
+- **Fuzzy search** uses Levenshtein distance. Edit tolerance scales with word length: 0 for ≤3 chars, 1 for 4-5 chars, 2 for 6+ chars. Enabled by default.
+- **Facets** are computed from all matching results before pagination, giving accurate counts regardless of page.
+- **Did-you-mean** only activates when zero results are found, checking against indexed titles and historically successful search terms.
+- **Click tracking** records which result was clicked and at what position, enabling CTR and rank quality analytics.
+- **Synonyms** are bidirectional: adding "tee" → ["t-shirt"] means searching for either term finds both.
+- **Highlights** wrap matched terms in `<mark>` tags for rendering in search result UIs.

package/dist/__tests__/controllers.test.d.ts

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

package/dist/__tests__/controllers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controllers.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/controllers.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/embedding-provider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=embedding-provider.test.d.ts.map

package/dist/__tests__/embedding-provider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-provider.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/embedding-provider.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/endpoint-security.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=endpoint-security.test.d.ts.map

package/dist/__tests__/endpoint-security.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-security.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/endpoint-security.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/meilisearch-provider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=meilisearch-provider.test.d.ts.map

package/dist/__tests__/meilisearch-provider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meilisearch-provider.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/meilisearch-provider.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/service-impl.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service-impl.test.d.ts.map

package/dist/__tests__/service-impl.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-impl.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/service-impl.test.ts"],"names":[],"mappings":""}

package/dist/admin/components/index.d.ts

@@ -0,0 +1,2 @@
+export { SearchAnalytics } from "./search-analytics";
+//# sourceMappingURL=index.d.ts.map

package/dist/admin/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/admin/components/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/admin/components/search-analytics.d.ts

@@ -0,0 +1,2 @@
+export declare function SearchAnalytics(): import("react").JSX.Element;
+//# sourceMappingURL=search-analytics.d.ts.map

package/dist/admin/components/search-analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-analytics.d.ts","sourceRoot":"","sources":["../../../src/admin/components/search-analytics.tsx"],"names":[],"mappings":"AA4FA,wBAAgB,eAAe,gCA+T9B"}

package/dist/admin/endpoints/analytics.d.ts

@@ -0,0 +1,15 @@
+export declare const analyticsEndpoint: import("better-call").StrictEndpoint<"/admin/search/analytics", {
+    method: "GET";
+}, {
+    analytics: {
+        indexedItems: number;
+        totalQueries: number;
+        uniqueTerms: number;
+        avgResultCount: number;
+        zeroResultCount: number;
+        zeroResultRate: number;
+        clickThroughRate: number;
+        avgClickPosition: number;
+    };
+}>;
+//# sourceMappingURL=analytics.d.ts.map

package/dist/admin/endpoints/analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/analytics.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;EAW7B,CAAC"}

package/dist/admin/endpoints/bulk-index.d.ts

@@ -0,0 +1,20 @@
+import { z } from "@86d-app/core";
+export declare const bulkIndex: import("better-call").StrictEndpoint<"/admin/search/index/bulk", {
+    method: "POST";
+    body: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            entityType: z.ZodString;
+            entityId: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            url: z.ZodString;
+            image: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, {
+    indexed: number;
+    errors: number;
+}>;
+//# sourceMappingURL=bulk-index.d.ts.map

package/dist/admin/endpoints/bulk-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-index.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/bulk-index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;EA8BrB,CAAC"}

package/dist/admin/endpoints/click-analytics.d.ts

@@ -0,0 +1,7 @@
+export declare const clickAnalyticsEndpoint: import("better-call").StrictEndpoint<"/admin/search/clicks", {
+    method: "GET";
+}, {
+    clickThroughRate: number;
+    avgClickPosition: number;
+}>;
+//# sourceMappingURL=click-analytics.d.ts.map

package/dist/admin/endpoints/click-analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"click-analytics.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/click-analytics.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB;;;;;EAYlC,CAAC"}

package/dist/admin/endpoints/get-settings.d.ts

@@ -0,0 +1,17 @@
+export declare const getSettings: import("better-call").StrictEndpoint<"/admin/search/settings", {
+    method: "GET";
+}, {
+    meilisearch: {
+        configured: boolean;
+        host: string | null;
+        apiKey: string | null;
+        indexUid: string;
+    };
+    embeddings: {
+        configured: boolean;
+        provider: string | null;
+        model: string;
+    };
+    indexCount: number;
+}>;
+//# sourceMappingURL=get-settings.d.ts.map

package/dist/admin/endpoints/get-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-settings.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/get-settings.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;EAsCvB,CAAC"}

package/dist/admin/endpoints/index-manage.d.ts

@@ -0,0 +1,26 @@
+import { z } from "@86d-app/core";
+export declare const indexItem: import("better-call").StrictEndpoint<"/admin/search/index", {
+    method: "POST";
+    body: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        title: z.ZodString;
+        body: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        url: z.ZodString;
+        image: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, {
+    item: import("../..").SearchIndexItem;
+}>;
+export declare const removeFromIndex: import("better-call").StrictEndpoint<"/admin/search/index/remove", {
+    method: "POST";
+    body: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+    }, z.core.$strip>;
+}, {
+    removed: boolean;
+}>;
+//# sourceMappingURL=index-manage.d.ts.map

package/dist/admin/endpoints/index-manage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-manage.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/index-manage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,CAAC,EAAE,MAAM,eAAe,CAAC;AAGvD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;EAuBrB,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;EAiB3B,CAAC"}

package/dist/admin/endpoints/index.d.ts

@@ -0,0 +1,125 @@
+export declare const adminEndpoints: {
+    "/admin/search/settings": import("better-call").StrictEndpoint<"/admin/search/settings", {
+        method: "GET";
+    }, {
+        meilisearch: {
+            configured: boolean;
+            host: string | null;
+            apiKey: string | null;
+            indexUid: string;
+        };
+        embeddings: {
+            configured: boolean;
+            provider: string | null;
+            model: string;
+        };
+        indexCount: number;
+    }>;
+    "/admin/search/analytics": import("better-call").StrictEndpoint<"/admin/search/analytics", {
+        method: "GET";
+    }, {
+        analytics: {
+            indexedItems: number;
+            totalQueries: number;
+            uniqueTerms: number;
+            avgResultCount: number;
+            zeroResultCount: number;
+            zeroResultRate: number;
+            clickThroughRate: number;
+            avgClickPosition: number;
+        };
+    }>;
+    "/admin/search/popular": import("better-call").StrictEndpoint<"/admin/search/popular", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+            limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        terms: import("../../service").PopularTerm[];
+    }>;
+    "/admin/search/zero-results": import("better-call").StrictEndpoint<"/admin/search/zero-results", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+            limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        terms: import("../../service").PopularTerm[];
+    }>;
+    "/admin/search/clicks": import("better-call").StrictEndpoint<"/admin/search/clicks", {
+        method: "GET";
+    }, {
+        clickThroughRate: number;
+        avgClickPosition: number;
+    }>;
+    "/admin/search/synonyms": import("better-call").StrictEndpoint<"/admin/search/synonyms", {
+        method: "GET";
+    }, {
+        synonyms: import("../..").SearchSynonym[];
+    }>;
+    "/admin/search/synonyms/add": import("better-call").StrictEndpoint<"/admin/search/synonyms/add", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            term: import("zod").ZodString;
+            synonyms: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        synonym: import("../..").SearchSynonym;
+    }>;
+    "/admin/search/synonyms/:id/delete": import("better-call").StrictEndpoint<"/admin/search/synonyms/:id/delete", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        success?: never;
+    } | {
+        success: boolean;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/search/index": import("better-call").StrictEndpoint<"/admin/search/index", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            entityType: import("zod").ZodString;
+            entityId: import("zod").ZodString;
+            title: import("zod").ZodString;
+            body: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            url: import("zod").ZodString;
+            image: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        item: import("../..").SearchIndexItem;
+    }>;
+    "/admin/search/index/remove": import("better-call").StrictEndpoint<"/admin/search/index/remove", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            entityType: import("zod").ZodString;
+            entityId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        removed: boolean;
+    }>;
+    "/admin/search/index/bulk": import("better-call").StrictEndpoint<"/admin/search/index/bulk", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                entityType: import("zod").ZodString;
+                entityId: import("zod").ZodString;
+                title: import("zod").ZodString;
+                body: import("zod").ZodOptional<import("zod").ZodString>;
+                tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                url: import("zod").ZodString;
+                image: import("zod").ZodOptional<import("zod").ZodString>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        indexed: number;
+        errors: number;
+    }>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/admin/endpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAY1B,CAAC"}