@channlize/core 0.2.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @channlize/core
 
+## 0.4.0
+
+### Minor Changes
+
+- 5663cd2: Make `@channlize/core` the single source for what the packages share.
+
+  - core exports `DEFAULT_BASE_URL`, `DEFAULT_TIMEOUT`, `EVENT_SEVERITIES`, `EVENT_KEY_PATTERN`, `isValidEventKey`, `keyKind` (widget vs. server key), `readChannlizeEnv` (the `CHANNLIZE_*` variables) and `parseApiError` (the API's error shape). `createNotifier`, the client and `@channlize/mcp` use them instead of their own copies.
+  - `ChannlizeError` gains `requestId` and `details` (the API's error body, e.g. `limit`, `used` and `resetAt` on a plan-limit 429). When a legacy route puts its human-readable text in `error`, it becomes the message instead of `HTTP <status>`.
+  - The chat types document where the API differs from them (ISO string timestamps, session summaries without `messages`).
+  - `@channlize/react` and `@channlize/mcp` re-export the error classes as values, so `instanceof` works without importing core.
+  - mcp tool errors no longer end with a doubled period when a core error message ends with one.
+
+- Release every `@channlize/*` package under one shared version. From 0.4.0 on, core, react, mcp and skills always publish together at the same version, so matching versions work together.
+
+## 0.2.2
+
+Not published on its own; these changes ship in 0.4.0.
+
+### Patch Changes
+
+- 097ad44: Log tracking no longer throws when the API refuses an event with a 429: `trackEvent` and `trackServerEvent` resolve with `{ success: false, id: '', dropped: 'plan_limit' | 'rate_limit' }` and log one console warning, so reaching the plan's log tracking limit (`PLAN_LIMIT_REACHED`) or the rate limit never breaks the calling app. `RateLimitError.code` is now `PLAN_LIMIT_REACHED` for plan-limit refusals (for example from `notify()`), and `TrackEventResult` is exported.
+
 ## 0.2.1
 
 ### Patch Changes

package/README.md

@@ -25,7 +25,7 @@ await notify('user.subscribed', { username: user.name, plan: 'Pro' });
 import { ChannlizeClient } from '@channlize/core';
 
 const client = new ChannlizeClient({
-  apiKey: 'your-api-key',
+  apiKey: 'wk_…', // public widget key
   projectId: 'your-project-id',
   baseUrl: 'https://api.channlize.com', // optional
   timeout: 10000, // optional, default 10s
@@ -47,18 +47,15 @@ const response = await client.submitContactForm({
   },
 });
 
-console.log('Submission ID:', response.id);
-console.log('Slack thread:', response.slackThreadUrl);
+console.log('Conversation:', response.conversationId);
 ```
 
 ### Chat Sessions
 
 ```typescript
 // Create a new chat session
-const sessionResponse = await client.createChatSession({
-  userAgent: navigator.userAgent,
-  pageUrl: window.location.href,
-});
+// Metadata is optional; pageUrl and userAgent are added in the browser.
+const sessionResponse = await client.createChatSession({ plan: 'pro' });
 
 const session = sessionResponse.session;
 
@@ -149,6 +146,10 @@ await client.trackEvent('page.viewed', { properties: { path: '/pricing' } });
 await client.trackServerEvent('webhook.received', { severity: 'warning' });
 ```
 
+Log tracking never breaks your app over limits: when the API answers `429` (the rate limit, or your plan's log tracking limit for the billing period, `PLAN_LIMIT_REACHED`), both calls resolve with `{ success: false, id: '', dropped: 'plan_limit' | 'rate_limit' }` instead of throwing, and the client logs one console warning. Other errors (bad input, network) still throw.
+
+`notify()` is different: a `429` there throws a `RateLimitError` whose `code` is `PLAN_LIMIT_REACHED` when the plan's Events limit is reached, so your server can see that the Slack message was not sent.
+
 ### Error Handling
 
 ```typescript
@@ -201,8 +202,8 @@ interface ChannlizeConfig {
 - `getChatMessages(sessionId: string, limit?: number, offset?: number): Promise<ChatMessage[]>`
 - `closeChatSession(sessionId: string): Promise<ChatSession>`
 - `notify(event: string, data?: Record<string, unknown>, options?: NotifyOptions): Promise<NotifyResponse>` — Events (server)
-- `trackEvent(name: string, options?: TrackEventOptions)` — log tracking (browser)
-- `trackServerEvent(name: string, options?)` — log tracking (server)
+- `trackEvent(name: string, options?: TrackEventOptions): Promise<TrackEventResult>` — log tracking (browser); a 429 resolves with `dropped`
+- `trackServerEvent(name: string, options?): Promise<TrackEventResult>` — log tracking (server); a 429 resolves with `dropped`
 
 ### createNotifier
 
@@ -210,7 +211,7 @@ interface ChannlizeConfig {
 
 ### Types
 
-All TypeScript types are exported from the package:
+All TypeScript types are exported from the package. The error classes (`ChannlizeError`, `ValidationError`, `AuthenticationError`, `RateLimitError`) are values, so import them without `type` for `instanceof` checks (see Error Handling):
 
 ```typescript
 import type {
@@ -222,13 +223,20 @@ import type {
   CreateContactResponse,
   CreateChatSessionResponse,
   SendMessageResponse,
-  ChannlizeError,
-  ValidationError,
-  AuthenticationError,
-  RateLimitError,
+  NotifyResponse,
+  TrackEventResult,
 } from '@channlize/core';
 ```
 
+## Documentation
+
+- Guide: https://channlize.com/docs/core
+- All docs: https://channlize.com/docs (quick start, API keys, troubleshooting)
+
+## Changelog
+
+[CHANGELOG.md](./CHANGELOG.md) lists every release of `@channlize/core`. Product updates: https://channlize.com/docs/changelog
+
 ## License
 
 MIT

package/dist/index.d.mts

@@ -1,8 +1,73 @@
+/**
+ * Helpers shared by `@channlize/core`, `@channlize/react` and
+ * `@channlize/mcp`: defaults, key detection, environment variables, event
+ * keys and the API's error shape. Core is the single source for these.
+ */
+/** Default API base URL. */
+declare const DEFAULT_BASE_URL = "https://api.channlize.com";
+/** Default request timeout, in milliseconds. */
+declare const DEFAULT_TIMEOUT = 10000;
+/** Log tracking severities, lowest first. */
+declare const EVENT_SEVERITIES: readonly ["info", "warning", "error"];
+/**
+ * Valid Events key (same rule as the API): lowercase letters, digits,
+ * dots, underscores and dashes, e.g. `user.subscribed`. At most 100
+ * characters.
+ */
+declare const EVENT_KEY_PATTERN: RegExp;
+/** Whether `event` is a valid Events key for `notify`. */
+declare function isValidEventKey(event: unknown): event is string;
+type KeyKind = 'widget' | 'server';
+/**
+ * `wk_…` is the public widget key (browser: contact form, chat, browser
+ * log tracking); anything else is a server API key (`ch_live_…`).
+ */
+declare function keyKind(key: string): KeyKind;
+/** The `CHANNLIZE_*` environment variables, trimmed (empty → undefined). */
+interface ChannlizeEnv {
+    /** `CHANNLIZE_SERVER_API_KEY` */
+    serverApiKey?: string;
+    /** `CHANNLIZE_WIDGET_KEY` */
+    widgetKey?: string;
+    /** `CHANNLIZE_API_KEY` (either kind of key) */
+    apiKey?: string;
+    /** `CHANNLIZE_PROJECT_ID` */
+    projectId?: string;
+    /** `CHANNLIZE_BASE_URL` */
+    baseUrl?: string;
+    /** `CHANNLIZE_TIMEOUT` (milliseconds, unparsed) */
+    timeout?: string;
+}
+/**
+ * Reads the `CHANNLIZE_*` environment variables. Safe in browsers and edge
+ * runtimes without `process` (everything is undefined there).
+ */
+declare function readChannlizeEnv(env?: Record<string, string | undefined> | undefined): ChannlizeEnv;
+/** A failed API response, parsed from its JSON body. */
+interface ApiErrorInfo {
+    status: number;
+    /** Human-readable text (field messages joined with `, `). */
+    message: string;
+    /** Machine-readable code: the body's `code`, else its `error` (e.g. `NOT_FOUND`). */
+    code?: string;
+    /** `requestId` from the body, to quote to support. */
+    requestId?: string;
+    /** The parsed body (e.g. `limit`, `used`, `resetAt` on a plan-limit 429). */
+    body: Record<string, unknown>;
+}
+/**
+ * Parses the API's error shape (`api/lib/api/error.ts`):
+ * `{ statusCode, error: "NOT_FOUND", message: string | string[], requestId? }`.
+ * A few legacy routes put the human text in `error`.
+ */
+declare function parseApiError(status: number, body: unknown, statusText?: string): ApiErrorInfo;
+
 /**
  * Core types for Channlize SDK
  */
+
 /** Severity for log tracking (`trackEvent` / `trackServerEvent`); Slack alerts use project settings. */
-type EventSeverity = 'info' | 'warning' | 'error';
+type EventSeverity = (typeof EVENT_SEVERITIES)[number];
 /** Options for log tracking (`trackEvent` / `trackServerEvent`). */
 interface TrackEventOptions {
     properties?: Record<string, unknown>;
@@ -105,11 +170,15 @@ interface ChatMessage {
     id: string;
     /** Message content */
     content: string;
-    /** Message timestamp */
+    /**
+     * Message timestamp. The API sends an ISO 8601 string, which
+     * `ChannlizeClient` passes through as is; `@channlize/react` converts it
+     * to a `Date`. Wrap it in `new Date(...)` before using `Date` methods.
+     */
     timestamp: Date;
     /** Message author (user or agent) */
     author: 'user' | 'agent';
-    /** Author metadata */
+    /** Author metadata (`name` / `email` can be `null` in message history) */
     authorData?: {
         name?: string;
         email?: string;
@@ -133,15 +202,23 @@ interface FileAttachment {
 interface ChatSession {
     /** Session ID */
     id: string;
-    /** Session status */
+    /**
+     * Session status. `createChatSession` answers `active`; `getChatSession`
+     * and `closeChatSession` answer the conversation's status (`open`,
+     * `pending`, `resolved` or `closed`).
+     */
     status: 'active' | 'closed' | 'waiting';
-    /** Messages in the session */
+    /**
+     * Messages in the session. Only `createChatSession` returns it (empty);
+     * `getChatSession`, `closeChatSession` and `sendMessage` return a session
+     * summary without it. Load history with `getChatMessages`.
+     */
     messages: ChatMessage[];
     /** Session metadata */
     metadata?: Record<string, unknown>;
-    /** Created timestamp */
+    /** Created timestamp (an ISO 8601 string on the wire; not sent by `closeChatSession`) */
     createdAt: Date;
-    /** Updated timestamp */
+    /** Updated timestamp (an ISO 8601 string on the wire) */
     updatedAt: Date;
 }
 interface ApiResponse<T = unknown> {
@@ -178,7 +255,7 @@ interface CreateChatSessionResponse {
 interface SendMessageResponse {
     /** The sent message */
     message: ChatMessage;
-    /** Updated session */
+    /** The session (the API sends only `id` and `status`) */
     session: ChatSession;
 }
 /**
@@ -187,6 +264,13 @@ interface SendMessageResponse {
 declare class ChannlizeError extends Error {
     statusCode?: number | undefined;
     code?: string | undefined;
+    /** The API's `requestId` for a failed response, to quote to support. */
+    requestId?: string;
+    /**
+     * The API's JSON error body, e.g. `limit`, `used`, `resetAt` and
+     * `upgradeUrl` on a plan-limit 429. Undefined for network errors.
+     */
+    details?: Record<string, unknown>;
     constructor(message: string, statusCode?: number | undefined, code?: string | undefined);
 }
 declare class ValidationError extends ChannlizeError {
@@ -196,8 +280,25 @@ declare class ValidationError extends ChannlizeError {
 declare class AuthenticationError extends ChannlizeError {
     constructor(message?: string);
 }
+/**
+ * A 429. `code` is `PLAN_LIMIT_REACHED` when the organization is past its
+ * plan's limit for the billing period (the API's 110 % hard cap), else
+ * `RATE_LIMIT_ERROR`.
+ */
 declare class RateLimitError extends ChannlizeError {
-    constructor(message?: string);
+    constructor(message?: string, code?: string);
+}
+/**
+ * What `trackEvent` / `trackServerEvent` resolve with. When the API refuses
+ * the event with a 429 (rate limit or plan limit), the call resolves with
+ * `success: false` and `dropped` instead of throwing: log tracking never
+ * breaks the app that calls it.
+ */
+interface TrackEventResult {
+    success: boolean;
+    id: string;
+    /** Set when the event was refused and not stored. */
+    dropped?: 'plan_limit' | 'rate_limit';
 }
 
 /**
@@ -242,10 +343,8 @@ declare class ChannlizeClient<TEvents extends object = ChannlizeEvents> {
      * Log tracking: record a log line from the browser (widget key →
      * `POST /public/events`). Shown under Log tracking in the dashboard.
      */
-    trackEvent(name: string, options?: TrackEventOptions): Promise<{
-        success: boolean;
-        id: string;
-    }>;
+    trackEvent(name: string, options?: TrackEventOptions): Promise<TrackEventResult>;
+    private sendBrowserEvent;
     /**
      * Log tracking from a trusted server, using the organization API key
      * (`POST /v1/events`). Shown under Log tracking in the dashboard.
@@ -253,10 +352,15 @@ declare class ChannlizeClient<TEvents extends object = ChannlizeEvents> {
     trackServerEvent(name: string, options?: {
         properties?: Record<string, unknown>;
         severity?: EventSeverity;
-    }): Promise<{
-        success: boolean;
-        id: string;
-    }>;
+    }): Promise<TrackEventResult>;
+    /**
+     * Log tracking must never break the caller: a 429 (rate limit, or the
+     * plan's limit for the billing period) resolves with `success: false`
+     * and `dropped` instead of throwing, with one console warning per client.
+     */
+    private nonFatalTracking;
+    private warnedDropped;
+    private sendServerEvent;
     /**
      * Events: post a Slack message from your server when something happens
      * (`POST /v1/notify`). The event key picks the channel and message
@@ -284,5 +388,5 @@ type Notifier<TEvents extends object = ChannlizeEvents> = <K extends NotifyEvent
  */
 declare function createNotifier<TEvents extends object = ChannlizeEvents>(config?: NotifierConfig): Notifier<TEvents>;
 
-export { AuthenticationError, ChannlizeClient, ChannlizeError, RateLimitError, ValidationError, createNotifier, ChannlizeClient as default };
-export type { ApiResponse, ChannlizeConfig, ChannlizeEvents, ChatMessage, ChatSession, ContactFormData, CreateChatSessionResponse, CreateContactResponse, EventSeverity, FileAttachment, Notifier, NotifierConfig, NotifyEventData, NotifyEventName, NotifyOptions, NotifyResponse, SendMessageResponse, TrackEventOptions };
+export { AuthenticationError, ChannlizeClient, ChannlizeError, DEFAULT_BASE_URL, DEFAULT_TIMEOUT, EVENT_KEY_PATTERN, EVENT_SEVERITIES, RateLimitError, ValidationError, createNotifier, ChannlizeClient as default, isValidEventKey, keyKind, parseApiError, readChannlizeEnv };
+export type { ApiErrorInfo, ApiResponse, ChannlizeConfig, ChannlizeEnv, ChannlizeEvents, ChatMessage, ChatSession, ContactFormData, CreateChatSessionResponse, CreateContactResponse, EventSeverity, FileAttachment, KeyKind, Notifier, NotifierConfig, NotifyEventData, NotifyEventName, NotifyOptions, NotifyResponse, SendMessageResponse, TrackEventOptions, TrackEventResult };

package/dist/index.d.ts

@@ -1,8 +1,73 @@
+/**
+ * Helpers shared by `@channlize/core`, `@channlize/react` and
+ * `@channlize/mcp`: defaults, key detection, environment variables, event
+ * keys and the API's error shape. Core is the single source for these.
+ */
+/** Default API base URL. */
+declare const DEFAULT_BASE_URL = "https://api.channlize.com";
+/** Default request timeout, in milliseconds. */
+declare const DEFAULT_TIMEOUT = 10000;
+/** Log tracking severities, lowest first. */
+declare const EVENT_SEVERITIES: readonly ["info", "warning", "error"];
+/**
+ * Valid Events key (same rule as the API): lowercase letters, digits,
+ * dots, underscores and dashes, e.g. `user.subscribed`. At most 100
+ * characters.
+ */
+declare const EVENT_KEY_PATTERN: RegExp;
+/** Whether `event` is a valid Events key for `notify`. */
+declare function isValidEventKey(event: unknown): event is string;
+type KeyKind = 'widget' | 'server';
+/**
+ * `wk_…` is the public widget key (browser: contact form, chat, browser
+ * log tracking); anything else is a server API key (`ch_live_…`).
+ */
+declare function keyKind(key: string): KeyKind;
+/** The `CHANNLIZE_*` environment variables, trimmed (empty → undefined). */
+interface ChannlizeEnv {
+    /** `CHANNLIZE_SERVER_API_KEY` */
+    serverApiKey?: string;
+    /** `CHANNLIZE_WIDGET_KEY` */
+    widgetKey?: string;
+    /** `CHANNLIZE_API_KEY` (either kind of key) */
+    apiKey?: string;
+    /** `CHANNLIZE_PROJECT_ID` */
+    projectId?: string;
+    /** `CHANNLIZE_BASE_URL` */
+    baseUrl?: string;
+    /** `CHANNLIZE_TIMEOUT` (milliseconds, unparsed) */
+    timeout?: string;
+}
+/**
+ * Reads the `CHANNLIZE_*` environment variables. Safe in browsers and edge
+ * runtimes without `process` (everything is undefined there).
+ */
+declare function readChannlizeEnv(env?: Record<string, string | undefined> | undefined): ChannlizeEnv;
+/** A failed API response, parsed from its JSON body. */
+interface ApiErrorInfo {
+    status: number;
+    /** Human-readable text (field messages joined with `, `). */
+    message: string;
+    /** Machine-readable code: the body's `code`, else its `error` (e.g. `NOT_FOUND`). */
+    code?: string;
+    /** `requestId` from the body, to quote to support. */
+    requestId?: string;
+    /** The parsed body (e.g. `limit`, `used`, `resetAt` on a plan-limit 429). */
+    body: Record<string, unknown>;
+}
+/**
+ * Parses the API's error shape (`api/lib/api/error.ts`):
+ * `{ statusCode, error: "NOT_FOUND", message: string | string[], requestId? }`.
+ * A few legacy routes put the human text in `error`.
+ */
+declare function parseApiError(status: number, body: unknown, statusText?: string): ApiErrorInfo;
+
 /**
  * Core types for Channlize SDK
  */
+
 /** Severity for log tracking (`trackEvent` / `trackServerEvent`); Slack alerts use project settings. */
-type EventSeverity = 'info' | 'warning' | 'error';
+type EventSeverity = (typeof EVENT_SEVERITIES)[number];
 /** Options for log tracking (`trackEvent` / `trackServerEvent`). */
 interface TrackEventOptions {
     properties?: Record<string, unknown>;
@@ -105,11 +170,15 @@ interface ChatMessage {
     id: string;
     /** Message content */
     content: string;
-    /** Message timestamp */
+    /**
+     * Message timestamp. The API sends an ISO 8601 string, which
+     * `ChannlizeClient` passes through as is; `@channlize/react` converts it
+     * to a `Date`. Wrap it in `new Date(...)` before using `Date` methods.
+     */
     timestamp: Date;
     /** Message author (user or agent) */
     author: 'user' | 'agent';
-    /** Author metadata */
+    /** Author metadata (`name` / `email` can be `null` in message history) */
     authorData?: {
         name?: string;
         email?: string;
@@ -133,15 +202,23 @@ interface FileAttachment {
 interface ChatSession {
     /** Session ID */
     id: string;
-    /** Session status */
+    /**
+     * Session status. `createChatSession` answers `active`; `getChatSession`
+     * and `closeChatSession` answer the conversation's status (`open`,
+     * `pending`, `resolved` or `closed`).
+     */
     status: 'active' | 'closed' | 'waiting';
-    /** Messages in the session */
+    /**
+     * Messages in the session. Only `createChatSession` returns it (empty);
+     * `getChatSession`, `closeChatSession` and `sendMessage` return a session
+     * summary without it. Load history with `getChatMessages`.
+     */
     messages: ChatMessage[];
     /** Session metadata */
     metadata?: Record<string, unknown>;
-    /** Created timestamp */
+    /** Created timestamp (an ISO 8601 string on the wire; not sent by `closeChatSession`) */
     createdAt: Date;
-    /** Updated timestamp */
+    /** Updated timestamp (an ISO 8601 string on the wire) */
     updatedAt: Date;
 }
 interface ApiResponse<T = unknown> {
@@ -178,7 +255,7 @@ interface CreateChatSessionResponse {
 interface SendMessageResponse {
     /** The sent message */
     message: ChatMessage;
-    /** Updated session */
+    /** The session (the API sends only `id` and `status`) */
     session: ChatSession;
 }
 /**
@@ -187,6 +264,13 @@ interface SendMessageResponse {
 declare class ChannlizeError extends Error {
     statusCode?: number | undefined;
     code?: string | undefined;
+    /** The API's `requestId` for a failed response, to quote to support. */
+    requestId?: string;
+    /**
+     * The API's JSON error body, e.g. `limit`, `used`, `resetAt` and
+     * `upgradeUrl` on a plan-limit 429. Undefined for network errors.
+     */
+    details?: Record<string, unknown>;
     constructor(message: string, statusCode?: number | undefined, code?: string | undefined);
 }
 declare class ValidationError extends ChannlizeError {
@@ -196,8 +280,25 @@ declare class ValidationError extends ChannlizeError {
 declare class AuthenticationError extends ChannlizeError {
     constructor(message?: string);
 }
+/**
+ * A 429. `code` is `PLAN_LIMIT_REACHED` when the organization is past its
+ * plan's limit for the billing period (the API's 110 % hard cap), else
+ * `RATE_LIMIT_ERROR`.
+ */
 declare class RateLimitError extends ChannlizeError {
-    constructor(message?: string);
+    constructor(message?: string, code?: string);
+}
+/**
+ * What `trackEvent` / `trackServerEvent` resolve with. When the API refuses
+ * the event with a 429 (rate limit or plan limit), the call resolves with
+ * `success: false` and `dropped` instead of throwing: log tracking never
+ * breaks the app that calls it.
+ */
+interface TrackEventResult {
+    success: boolean;
+    id: string;
+    /** Set when the event was refused and not stored. */
+    dropped?: 'plan_limit' | 'rate_limit';
 }
 
 /**
@@ -242,10 +343,8 @@ declare class ChannlizeClient<TEvents extends object = ChannlizeEvents> {
      * Log tracking: record a log line from the browser (widget key →
      * `POST /public/events`). Shown under Log tracking in the dashboard.
      */
-    trackEvent(name: string, options?: TrackEventOptions): Promise<{
-        success: boolean;
-        id: string;
-    }>;
+    trackEvent(name: string, options?: TrackEventOptions): Promise<TrackEventResult>;
+    private sendBrowserEvent;
     /**
      * Log tracking from a trusted server, using the organization API key
      * (`POST /v1/events`). Shown under Log tracking in the dashboard.
@@ -253,10 +352,15 @@ declare class ChannlizeClient<TEvents extends object = ChannlizeEvents> {
     trackServerEvent(name: string, options?: {
         properties?: Record<string, unknown>;
         severity?: EventSeverity;
-    }): Promise<{
-        success: boolean;
-        id: string;
-    }>;
+    }): Promise<TrackEventResult>;
+    /**
+     * Log tracking must never break the caller: a 429 (rate limit, or the
+     * plan's limit for the billing period) resolves with `success: false`
+     * and `dropped` instead of throwing, with one console warning per client.
+     */
+    private nonFatalTracking;
+    private warnedDropped;
+    private sendServerEvent;
     /**
      * Events: post a Slack message from your server when something happens
      * (`POST /v1/notify`). The event key picks the channel and message
@@ -284,5 +388,5 @@ type Notifier<TEvents extends object = ChannlizeEvents> = <K extends NotifyEvent
  */
 declare function createNotifier<TEvents extends object = ChannlizeEvents>(config?: NotifierConfig): Notifier<TEvents>;
 
-export { AuthenticationError, ChannlizeClient, ChannlizeError, RateLimitError, ValidationError, createNotifier, ChannlizeClient as default };
-export type { ApiResponse, ChannlizeConfig, ChannlizeEvents, ChatMessage, ChatSession, ContactFormData, CreateChatSessionResponse, CreateContactResponse, EventSeverity, FileAttachment, Notifier, NotifierConfig, NotifyEventData, NotifyEventName, NotifyOptions, NotifyResponse, SendMessageResponse, TrackEventOptions };
+export { AuthenticationError, ChannlizeClient, ChannlizeError, DEFAULT_BASE_URL, DEFAULT_TIMEOUT, EVENT_KEY_PATTERN, EVENT_SEVERITIES, RateLimitError, ValidationError, createNotifier, ChannlizeClient as default, isValidEventKey, keyKind, parseApiError, readChannlizeEnv };
+export type { ApiErrorInfo, ApiResponse, ChannlizeConfig, ChannlizeEnv, ChannlizeEvents, ChatMessage, ChatSession, ContactFormData, CreateChatSessionResponse, CreateContactResponse, EventSeverity, FileAttachment, KeyKind, Notifier, NotifierConfig, NotifyEventData, NotifyEventName, NotifyOptions, NotifyResponse, SendMessageResponse, TrackEventOptions, TrackEventResult };