@jchat/addon-sdk 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index2.d.mts

@@ -0,0 +1,601 @@
+import { i as IconPack, n as IconComponent, r as IconName } from "./types.mjs";
+import { AddonCommandDefinition, AddonCommandParameter, AddonManifest, AddonPermissionDefinition, MOUNT_POINTS, MountPoint } from "./contracts.mjs";
+import { InfiniteData, MutationFunction, QueryFunction, QueryFunctionContext, QueryKey, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryResult, useQueryClient } from "@tanstack/react-query";
+import { Elysia, t } from "elysia";
+import { ColumnType, Generated, Insertable, JSONColumnType, Kysely, Selectable, Updateable } from "kysely";
+//#region src/i18n.d.ts
+export declare const HOST_LANGUAGES: readonly ["ar", "bg", "hr", "de", "el", "en", "es", "fr", "he", "hi", "kn", "ml", "nl", "pt", "ro", "ru", "ta", "te", "tr", "ur"];
+export type HostLanguage = (typeof HOST_LANGUAGES)[number];
+export type AddonTranslationDictionary = Record<string, unknown>;
+export type AddonTranslationResources = Record<string, AddonTranslationDictionary>;
+export type AddonLocaleLoader = (locale: string) => Promise<AddonTranslationDictionary> | AddonTranslationDictionary;
+export interface LocaleContextValue {
+  locale: string;
+  dir: "ltr" | "rtl";
+}
+export declare const LocaleContext: import("react").Context<LocaleContextValue>;
+export interface TranslatorOptions {
+  resources?: AddonTranslationResources;
+  defaultLocale?: string;
+  fallbackLocale?: string;
+}
+export type TranslateFunction<TKeys extends string = string> = (key: TKeys | (string & {}), paramsOrLang?: Record<string, unknown> | string, maybeLang?: string) => string;
+/**
+ * Creates a standalone translation function for backend server routes (`src/api.ts`) or utilities.
+ *
+ * @param resources - Dictionary of translation resources (e.g., `{ en: enJson, ta: taJson }`).
+ * @param defaultLocale - Default locale to use if not specified per call (defaults to "en").
+ * @param fallbackLocale - Fallback locale if a key is missing in the target language (defaults to
+ *   "en").
+ */
+export declare function createTranslator<TResources extends AddonTranslationResources = AddonTranslationResources>(resources?: TResources, defaultLocale?: string, fallbackLocale?: string): TranslateFunction<TResources extends {
+  en: infer TEn;
+} ? TEn extends Record<string, unknown> ? Extract<keyof TEn, string> : string : string>;
+/**
+ * Hook to access the current active host locale and text direction in an addon component.
+ *
+ * @example
+ *   ;```tsx
+ *   import { useLocale } from "@jchat/addon-sdk"
+ *
+ *   export default function MyAddon() {
+ *     const { locale, dir, isRtl } = useLocale()
+ *     return <div dir={dir}>Current language: {locale}</div>
+ *   }
+ *   ```
+ */
+export declare function useLocale(): {
+  locale: string;
+  dir: "ltr" | "rtl";
+  isRtl: boolean;
+};
+/**
+ * Hook to access translation function and locale metadata inside addon components. Automatically
+ * synchronizes with host language switches and falls back to English. Supports static dictionary
+ * resources or dynamic async locale loaders.
+ *
+ * @example
+ *   ;```tsx
+ *   import { useTranslation } from "@jchat/addon-sdk"
+ *   import locales from "./locales"
+ *
+ *   export default function MyAddon() {
+ *     const { t, locale, dir } = useTranslation(locales)
+ *     return (
+ *       <div dir={dir}>
+ *         <h1>{t("welcome", { name: "Guest" })}</h1>
+ *       </div>
+ *     )
+ *   }
+ *   ```
+ *
+ * @param resourcesOrLoader - Addon-scoped translation dictionaries or async chunk loader.
+ * @param fallbackLocale - Fallback language code when a string is missing (default: "en").
+ */
+export declare function useTranslation<TResources extends AddonTranslationResources | AddonLocaleLoader = AddonTranslationResources>(resourcesOrLoader?: TResources, fallbackLocale?: string): {
+  t: TranslateFunction<TResources extends {
+    en: infer TEn;
+  } ? TEn extends Record<string, unknown> ? Extract<keyof TEn, string> : string : string>;
+  locale: string;
+  dir: "ltr" | "rtl";
+  isRtl: boolean;
+  isReady: boolean;
+};
+//#endregion
+//#region src/query.d.ts
+export interface UseAddonQueryOptions<TData = unknown, TError = Error> extends Omit<UndefinedInitialDataOptions<TData, TError, TData, QueryKey>, "queryKey" | "queryFn"> {
+  /** The API path to fetch, automatically prefixed with `/api/v1/addons/<addonId>` */
+  path?: string;
+  /** Custom query key elements appended to the automatic path cache key */
+  queryKey?: QueryKey;
+  /** Custom query function override */
+  queryFn?: QueryFunction<TData, QueryKey>;
+}
+export interface UseAddonMutationOptions<TData = unknown, TVariables = unknown, TError = Error, TContext = unknown> extends Omit<UseMutationOptions<TData, TError, TVariables, TContext>, "mutationFn"> {
+  /** The target API path, or a dynamic function of mutation variables */
+  path?: string | ((variables: TVariables) => string);
+  /** HTTP method to use (defaults to 'POST') */
+  method?: "POST" | "PUT" | "DELETE";
+  /** Query keys to automatically invalidate upon successful mutation */
+  invalidateQueries?: QueryKey[];
+  /** Custom mutation function override */
+  mutationFn?: MutationFunction<TData, TVariables>;
+}
+export interface UseAddonInfiniteQueryOptions<TData = unknown, TError = Error, TPageParam = unknown> extends Omit<UndefinedInitialDataInfiniteOptions<TData, TError, InfiniteData<TData, TPageParam>, QueryKey, TPageParam>, "queryKey" | "queryFn"> {
+  /** The API path to fetch, or a dynamic function that receives pageParam and returns the path */
+  path?: string | ((pageParam: TPageParam) => string);
+  /** Custom query key elements appended to the automatic cache key */
+  queryKey?: QueryKey;
+  /** Custom query function override */
+  queryFn?: (context: QueryFunctionContext<QueryKey, TPageParam>) => Promise<TData>;
+}
+/**
+ * Perform a declarative, cached GET request using the host's shared React Query instance.
+ * Automatically injects authentication headers and prefixes addon paths.
+ *
+ * @example
+ *   ;```tsx
+ *   const { data, isLoading } = useAddonQuery<{ polls: Poll[] }>({
+ *     path: "/polls",
+ *     queryKey: [siteId]
+ *   })
+ *   ```
+ */
+export declare function useAddonQuery<TData = unknown, TError = Error>(options: UseAddonQueryOptions<TData, TError>): UseQueryResult<TData, TError>;
+/**
+ * Perform a paginated or infinite scrolling request using the host's shared React Query instance.
+ *
+ * @example
+ *   ;```tsx
+ *   const { data, fetchNextPage, hasNextPage } = useAddonInfiniteQuery<GifResponse, Error, number>({
+ *   path: (page) => `/trending?offset=${page * 20}`,
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage, allPages) => (lastPage.hasMore ? allPages.length : undefined)
+ *   })
+ *   ```
+ */
+export declare function useAddonInfiniteQuery<TData = unknown, TError = Error, TPageParam = unknown>(options: UseAddonInfiniteQueryOptions<TData, TError, TPageParam>): UseInfiniteQueryResult<InfiniteData<TData, TPageParam>, TError>;
+/**
+ * Perform a declarative mutation using the host's shared React Query instance. Automatically
+ * executes the request and can invalidate specified query keys upon success.
+ *
+ * @example
+ *   ;```tsx
+ *   const { mutate, isPending } = useAddonMutation<Poll, CreatePollInput>({
+ *     path: "/polls",
+ *     method: "POST",
+ *     invalidateQueries: [["/polls"]],
+ *     onSuccess: () => sdk.toast("Poll created!", "success")
+ *   })
+ *   ```
+ */
+export declare function useAddonMutation<TData = unknown, TVariables = unknown, TError = Error, TContext = unknown>(options: UseAddonMutationOptions<TData, TVariables, TError, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
+//#endregion
+//#region src/index.d.ts
+export type AddonJsonBody = Record<string, unknown> | unknown[] | null;
+/**
+ * @jchat/addon-sdk
+ *
+ *   Lightweight SDK for Jchat addon developers. Provides TypeScript types for addon props, manifest
+ *   schema, and host API access. This package is always EXTERNALISED from addon bundles — the host
+ *   app provides the runtime implementation.
+ */
+/** Minimal user profile accessible to addon backends. */
+export interface AddonUser {
+  /** Unique user identifier */
+  id: string;
+  /** Display name */
+  name: string;
+  /** Full display name */
+  displayName: string;
+  /** Full URL to the user's avatar image */
+  avatar: string;
+  /** User's gender identifier */
+  gender: string;
+}
+export interface AddonRequestUser {
+  id: string;
+  permissions?: string[];
+  siteId?: string;
+}
+/**
+ * Typed, schema-scoped database facade for an addon. The host deliberately omits raw execution,
+ * schema switching, dialect/connection access, and lifecycle methods.
+ */
+export type AddonDatabase<TDatabase = Record<string, Record<string, unknown>>> = Pick<Kysely<TDatabase>, "deleteFrom" | "fn" | "insertInto" | "selectFrom" | "transaction" | "updateTable">;
+/**
+ * Scoped caching and key-value client provided to addon server instances. Keys are automatically
+ * namespaced by the host as `addon:<addonId>:<key>`.
+ */
+export interface AddonCacheClient {
+  /** Retrieve a string or JSON-parsed value by key */
+  get: <T = string>(key: string) => Promise<T | null>;
+  /** Store a value with an optional time-to-live in seconds */
+  set: (key: string, value: unknown, ttlSeconds?: number) => Promise<void>;
+  /** Delete one or more keys */
+  del: (...keys: string[]) => Promise<number>;
+  /** Atomically increment a numeric counter and return the new value */
+  incr: (key: string) => Promise<number>;
+  /** Set a timeout on a key in seconds */
+  expire: (key: string, ttlSeconds: number) => Promise<boolean>;
+  /** Get the remaining time-to-live of a key in seconds (-2 if key does not exist, -1 if no TTL) */
+  ttl: (key: string) => Promise<number>;
+}
+export interface AddonServerEmitTarget {
+  /** Target a specific site (defaults to the request user's siteId) */
+  siteId?: string;
+  /** Target a specific chat room */
+  roomId?: string;
+  /** Target a specific user */
+  userId?: string;
+}
+export interface AddonMessageMutableData {
+  /** Message content (can be Slate JSON structure or string) */
+  content: unknown;
+  /** Optional message attachments */
+  attachments?: unknown[] | null;
+  /**
+   * Namespaced metadata bucket for this addon. Keyed as `metadata["addon:<addonId>"]`. Storing data
+   * here automatically attaches it to the message broadcast and database record.
+   */
+  metadata: Record<string, unknown>;
+}
+export interface AddonMessageContext {
+  /** The site ID where the message is being sent */
+  siteId: string;
+  /** The chat room ID */
+  roomId: string;
+  /** The authenticated user sending the message (read-only) */
+  user: AddonRequestUser;
+  /** Mutable message payload */
+  message: AddonMessageMutableData;
+  /** Convenience method to set metadata under this addon's namespace */
+  setMetadata: (key: string, value: unknown) => void;
+  /**
+   * Abort the message sending pipeline with a user-facing error code and reason. Only active during
+   * `beforeValidate` and `transformContent`.
+   */
+  abort: (error: {
+    code: string;
+    reason?: string;
+  }) => never;
+}
+export interface AddonMessageAfterSaveContext {
+  siteId: string;
+  roomId: string;
+  user: AddonRequestUser;
+  message: {
+    id: string;
+    content: unknown;
+    attachments?: unknown[] | null;
+    metadata?: Record<string, unknown> | null;
+    type: string;
+    createdAt: Date | string;
+  };
+}
+export interface AddonPipelineHooks {
+  /**
+   * Run before validation to inspect or guard actions (rate-limits, permission gates). Throw or
+   * call `context.abort()` to reject the message.
+   */
+  beforeValidate?: (context: AddonMessageContext) => Promise<void> | void;
+  /** Run before persistence to mutate text, parse slash commands, or enrich metadata. */
+  transformContent?: (context: AddonMessageContext) => Promise<void> | void;
+  /** Run asynchronously after database save (fire-and-forget observers). */
+  afterSave?: (context: AddonMessageAfterSaveContext) => Promise<void> | void;
+}
+/**
+ * Context provided to an addon's server-side factory. Parameterize it with the addon's table
+ * interface: `AddonServerContext<MyAddonDatabase>`.
+ */
+export interface AddonServerContext<TDatabase = Record<string, Record<string, unknown>>> {
+  /**
+   * Elysia / TypeBox schema validator for defining route validation schemas (`body`, `query`,
+   * `params`, `headers`). Provided directly by the host runtime so your addon server bundle does
+   * not need to bundle Elysia.
+   */
+  t: typeof t;
+  /**
+   * Retrieve the encrypted settings for this addon for a specific site. Internal secrets are
+   * automatically decrypted using the host's master key.
+   */
+  getConfig: (siteId: string) => Promise<Record<string, unknown>>;
+  /** Fetch a specific user's public profile */
+  getUser: (userId: string) => Promise<AddonUser | null>;
+  /** Efficiently fetch multiple user profiles in a single query. Returns a Map keyed by user ID. */
+  getUsers: (userIds: string[]) => Promise<Map<string, AddonUser>>;
+  /**
+   * Check whether the request user holds a given permission. Provides autocomplete for core Jchat
+   * permissions while also accepting any custom addon permission string.
+   *
+   * @param user - The user object from the request context
+   * @param permission - The permission to check, e.g., 'message.send' or 'addon.stories.view'
+   */
+  hasPermission: (user: AddonRequestUser | null | undefined, permission: string) => boolean;
+  /**
+   * A Kysely database instance scoped entirely to your addon's tables. You cannot access core Jchat
+   * tables (Users, Rooms, etc.) through this instance.
+   */
+  db: AddonDatabase<TDatabase>;
+  /** A secure, namespaced key-value cache client scoped to your addon (`addon:<addonId>:<key>`). */
+  cache: AddonCacheClient;
+  /**
+   * Broadcast a real-time event to connected clients across the site or room. Clients listen via
+   * `sdk.events.on('addon:<addonId>:<event>', callback)` or `sdk.events.on(event, callback)`.
+   */
+  emit: (event: string, payload: unknown, target?: AddonServerEmitTarget) => Promise<void>;
+  /**
+   * Register lifecycle interception hooks for chat messages. Hooks run in the core chat execution
+   * path with strict 50ms timeout guards and fail-open fault tolerance.
+   */
+  pipeline?: {
+    register: (hooks: AddonPipelineHooks) => void;
+  };
+  /**
+   * Cryptographically verify that this addon instance holds a valid host license entitlement.
+   * Commercial paid addons should invoke this or call `verifyAddonEntitlement(addonId, context)`.
+   *
+   * @param expectedAddonId - The canonical addon ID defined by the publisher
+   * @returns True if valid, or false if entitlement is missing or invalid
+   */
+  verifyEntitlement?: (expectedAddonId?: string) => boolean;
+}
+/**
+ * Elysia app instance provided to addon server endpoints with Jchat macro metadata (e.g.
+ * requirePermission) typed.
+ */
+export type AddonApp = Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {
+    user: AddonRequestUser;
+  };
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {
+    requirePermission?: string | string[];
+  };
+  macroFn: {};
+  parser: {};
+  response: {};
+}>;
+/**
+ * The entry point for your addon's server bundle. You should default-export a function matching
+ * this signature.
+ *
+ * @example
+ *   ;```ts
+ *   import { type AddonServerFactory } from '@jchat/addon-sdk'
+ *
+ *   const factory: AddonServerFactory = ({ db, hasPermission }, app) => {
+ *   return app.get('/trending', async () => { ... })
+ *   }
+ *   export default factory
+ *   ```
+ */
+export type AddonServerFactory<TDatabase = Record<string, Record<string, unknown>>> = (ctx: AddonServerContext<TDatabase>, app: AddonApp) => Elysia;
+/** Props passed to your addon's root React component by the Jchat host. */
+export interface AddonProps {
+  /** The mount point where this addon instance is rendered (e.g., 'chat-sidebar') */
+  mountPoint: MountPoint;
+  /** Information about the currently logged-in user (if any) */
+  user?: {
+    id: string;
+    name: string;
+    displayName?: string;
+    avatar?: string;
+    gender?: string;
+  };
+  /** The ID of the room the user is currently viewing (if applicable) */
+  roomId?: string;
+  /** The ID of the active Jchat site */
+  siteId?: string;
+  /** The active user locale (e.g. 'en', 'ta', 'ar') */
+  locale?: string;
+  /** Text direction for the current locale */
+  dir?: "ltr" | "rtl";
+  /** The message object when rendered inside 'chat-message-card' or 'chat-message-flair' */
+  message?: unknown;
+  /** The addon's specific payload extracted from message.metadata */
+  addonData?: unknown;
+}
+export interface AddonApi {
+  get: <TResponse = unknown>(path: string) => Promise<TResponse>;
+  post: <TResponse = unknown>(path: string, body?: AddonJsonBody) => Promise<TResponse>;
+  put: <TResponse = unknown>(path: string, body?: AddonJsonBody) => Promise<TResponse>;
+  delete: <TResponse = unknown>(path: string) => Promise<TResponse>;
+}
+/** First-class addon settings management interface provided by the host. */
+export interface AddonSettingsApi {
+  /** Fetch the current site's saved configuration for this addon */
+  get: <T = Record<string, unknown>>() => Promise<T | null>;
+  /** Save updated configuration for this addon for the current site */
+  save: <T = Record<string, unknown>>(settings: T) => Promise<void>;
+}
+export type AddonEventListener = (data: unknown) => void;
+/** A font option provided by the JChat host. */
+export interface AddonFont {
+  /** Display label shown to users (e.g. 'Modern', 'Elegant') */
+  label: string;
+  /** Font identifier stored in the database (e.g. 'poppins', 'lato') */
+  value: string;
+  /** CSS font-family string ready for use in inline styles */
+  family: string;
+  /** Google Fonts name for loading the font via a <link> tag */
+  googleName: string;
+  /** Relative size multiplier — apply this to base font sizes to match the host's rendering */
+  scale: number;
+}
+export interface AddonEditorInsertImagePayload {
+  src: string;
+  altText: string;
+  emoji?: {
+    col: number;
+    row: number;
+    size: number;
+  };
+  className?: string;
+}
+export interface AddonEditorInsertEmojiPayload {
+  col: number;
+  row: number;
+  unicode: string;
+  shortcode?: string;
+}
+export interface AddonEditorCommandMap {
+  INSERT_YOUTUBE_COMMAND: string;
+  INSERT_TEXT: string;
+  INSERT_TEXT_COMMAND: string;
+  INSERT_MENTION_COMMAND: string;
+  INSERT_IMAGE_COMMAND: AddonEditorInsertImagePayload;
+  INSERT_EMOJI_COMMAND: AddonEditorInsertEmojiPayload;
+  CLEAR_EDITOR: void;
+  CLEAR_EDITOR_COMMAND: void;
+}
+export type AddonEditorCommand = keyof AddonEditorCommandMap;
+export interface AddonEditorApi {
+  /**
+   * Trigger a specialized editor command defined by the host.
+   *
+   * @example
+   *   sdk.editor.dispatchCommand("INSERT_YOUTUBE_COMMAND", "dQw4w9WgXcQ")
+   */
+  dispatchCommand: <C extends AddonEditorCommand>(command: C, ...args: AddonEditorCommandMap[C] extends void ? [payload?: undefined] : [payload: AddonEditorCommandMap[C]]) => void;
+  /**
+   * Insert a low-level Slate node directly at the user's cursor position.
+   *
+   * @param node - A valid Slate Descendant or Fragment object
+   */
+  insertNode: (node: unknown) => void;
+  /**
+   * Upload and attach a file to the current message without inserting it inline. Users will see the
+   * file in the attachment bar below the editor.
+   */
+  addAttachment: (attachment: {
+    url: string;
+    name: string;
+    type: string;
+  }) => void;
+  /** Force the browser focus back to the editor input */
+  focus: () => void;
+}
+/**
+ * The bridge between your addon and the Jchat host application. Use the `useAddonSDK()` hook to
+ * access this interface in your components.
+ */
+export interface AddonSDK {
+  /**
+   * Make authenticated API calls to your addon's backend or core Jchat endpoints. All calls
+   * automatically include the current user's sessionId and site validation headers. Relative paths
+   * are automatically prefixed with `/api/v1/addons/<addonId>`.
+   */
+  api: AddonApi;
+  /**
+   * First-class settings API to load and save addon configuration without boilerplate path
+   * construction.
+   */
+  settings: AddonSettingsApi;
+  /**
+   * Display a temporary notification toast in the host UI.
+   *
+   * @param message - The text content to display
+   * @param variant - Visual style: 'default' (blue), 'success' (green), or 'error' (red)
+   */
+  toast: (message: string, variant?: "default" | "success" | "error") => void;
+  /**
+   * Navigate the host application to a different internal route.
+   *
+   * @param path - The target location, e.g., '/settings' or '/addons/store'
+   */
+  navigate: (path: string) => void;
+  /**
+   * Interaction utilities for the active Slate message editor. Only available if your addon is
+   * mounted near the chat input.
+   */
+  editor: AddonEditorApi;
+  /** Event Bus for reacting to real-time application state changes. */
+  events: {
+    /**
+     * Register a persistent listener for a specific event.
+     *
+     * @param event - Event name, e.g., 'room.message', 'user.typing'
+     */
+    on: (event: string, callback: AddonEventListener) => void;
+    /** Unregister a previously attached listener */
+    off: (event: string, callback: AddonEventListener) => void;
+  };
+  /**
+   * The list of fonts available in this JChat deployment, as configured by the site administrator.
+   * Use this to build a font picker or apply a matching font family in your addon UI.
+   */
+  supportedFonts?: AddonFont[];
+  /** The active user locale (e.g. 'en', 'ta', 'ar') */
+  locale: string;
+  /** Text direction for the active locale ('ltr' or 'rtl') */
+  dir: "ltr" | "rtl";
+}
+/**
+ * Seed data for your addon's tables, provided inside the addon's isolated schema.
+ *
+ * These documents are inserted into the addon's dedicated schema on installation and can be used to
+ * provide default values, references, or supporting data. The host guarantees that these documents
+ * do not conflict with core schemas or other addons.
+ */
+export interface AddonSeedDocument {
+  /** Addon-owned table name. Core prefixes the addon's isolated PostgreSQL schema. */
+  table: string;
+  /** Behavior when a row conflicts with an existing unique or primary key. */
+  conflict?: "error" | "ignore" | "update";
+  /** Required for update behavior; identifies the unique key used by ON CONFLICT. */
+  conflictColumns?: string[];
+  /** JSON-compatible rows inserted using parameterized values. */
+  rows: Record<string, unknown>[];
+}
+/** Define a manifest with full validation-friendly typing while preserving literal values. */
+export declare function defineAddonManifest<const TManifest extends AddonManifest>(manifest: TManifest): TManifest;
+/** Define a typed server factory without widening its addon database interface. */
+export declare function defineAddonServer<TDatabase = Record<string, Record<string, unknown>>>(factory: AddonServerFactory<TDatabase>): AddonServerFactory<TDatabase>;
+/**
+ * Access the host application's SDK. Provides authenticated API access, toast notifications, and
+ * navigation.
+ *
+ * This function is a shell; the real implementation is provided by the Jchat host environment at
+ * runtime.
+ *
+ * @example
+ *   ;```tsx
+ *   import { useAddonSDK } from "@jchat/addon-sdk"
+ *
+ *   export default function MyAddon({ mountPoint }: AddonProps) {
+ *     const sdk = useAddonSDK()
+ *
+ *     const handleClick = async () => {
+ *       const data = await sdk.api.get("/trending")
+ *       sdk.toast("Fetched trending posts!", "success")
+ *     }
+ *   }
+ *   ```
+ */
+export declare function useAddonSDK(): AddonSDK;
+/**
+ * Get the version of the addon SDK. This is useful for checking compatibility with the host
+ * application.
+ *
+ * @example
+ *   ;```tsx
+ *   import { getAddonSdkVersion } from "@jchat/addon-sdk"
+ *
+ *   console.log(getAddonSdkVersion())
+ *   ```
+ *
+ * @returns
+ */
+export declare function getAddonSdkVersion(): string;
+/**
+ * Verifies purchase entitlement and identity integrity for commercial addons. Throws an error if
+ * the addon fails entitlement verification or if its manifest ID has been tampered with to
+ * impersonate another addon.
+ *
+ * @example
+ *   ;```ts
+ *   export default defineAddonServer((context, app) => {
+ *   verifyAddonEntitlement("tubescanpro", context)
+ *   return app.get("/trending", async () => { ... })
+ *   })
+ *   ```
+ *
+ * @param addonId - The canonical addon ID defined by the publisher (e.g. 'tubescanpro')
+ * @param context - The AddonServerContext passed to the addon's server factory
+ * @returns True if valid
+ * @throws Error if entitlement verification fails
+ */
+export declare function verifyAddonEntitlement(addonId: string, context?: {
+  verifyEntitlement?: (expectedAddonId?: string) => boolean;
+}): boolean;
+//#endregion
+export { type AddonCommandDefinition, type AddonCommandParameter, type AddonManifest, type AddonPermissionDefinition, type ColumnType, type Generated, type IconComponent, type IconName, type IconPack, type InfiniteData, type Insertable, type JSONColumnType, MOUNT_POINTS, type MountPoint, type QueryKey, type Selectable, type Updateable, useQueryClient };

package/dist/state.d.mts

@@ -0,0 +1 @@
+export * from "jotai";

package/dist/state.mjs

@@ -0,0 +1,2 @@
+export * from "jotai";
+export {};

package/dist/types.d.mts

@@ -0,0 +1,12 @@
+import { ComponentType, SVGProps } from "react";
+import { icons } from "lucide-react";
+//#region ../icon/dist/types.d.mts
+//#region src/types.d.ts
+type IconComponent = ComponentType<SVGProps<SVGSVGElement>>;
+type LucideIconName = keyof typeof icons;
+type IconName = LucideIconName | "Youtube";
+declare const ICON_NAMES: readonly IconName[];
+type IconPack = Record<IconName, IconComponent>;
+//#endregion
+//#endregion
+export { IconPack as i, IconComponent as n, IconName as r, ICON_NAMES as t };

package/dist/ui.d.mts

@@ -0,0 +1 @@
+export * from "@jchat/ui";

package/dist/ui.mjs

@@ -0,0 +1,2 @@
+export * from "@jchat/ui";
+export {};