@cstar.help/js 0.16.1 → 0.17.2

package/README.md

@@ -2,10 +2,10 @@
 
 Official TypeScript SDK for the [cStar](https://cstar.help) customer support platform.
 
-- **Zero dependencies** — works with Node.js 18+ native `fetch`
-- **TypeScript-first** — full type definitions included
-- **Six entry points** — tree-shake what you don't need
-- **ESM + CJS** — works everywhere
+- **Native fetch** for HTTP, Supabase for realtime
+- **TypeScript-first**, with full type definitions included
+- **Focused entry points** for the part of cStar you're building with
+- **ESM + CJS** exports
 
 ## Install
 
@@ -17,37 +17,26 @@ npm install @cstar.help/js
 
 ## Which SDK Do I Need?
 
-cStar has one package with **six entry points**, each designed for a different context:
+cStar has one package with separate entry points for different workflows. Start here:
 
-| Import                     | Use Case                                  | Runs On           | Auth Required | Key Type             |
-| -------------------------- | ----------------------------------------- | ----------------- | ------------- | -------------------- |
-| `@cstar.help/js`           | **Admin dashboard / backend integration** | Server only       | Yes           | Secret (`sk_*`)      |
-| `@cstar.help/js/chat`      | Customer chat widget                      | Browser           | Yes           | Publishable (`pk_*`) |
-| `@cstar.help/js/library`   | Public knowledge base                     | Browser or server | No            | None                 |
-| `@cstar.help/js/community` | Public community forum                    | Browser or server | No            | None                 |
-| `@cstar.help/js/webhook`   | Webhook signature verification            | Server only       | No            | Signing secret       |
-| `@cstar.help/js/auth`      | Authentication utilities                  | Server only       | Yes           | Secret (`sk_*`)      |
+| Import                     | Use Case                                  | Runs On           | Auth Required | Key Type                 |
+| -------------------------- | ----------------------------------------- | ----------------- | ------------- | ------------------------ |
+| `@cstar.help/js`           | **Admin dashboard / backend integration** | Server only       | Yes           | Secret (`sk_*`)          |
+| `@cstar.help/js/chat`      | Customer chat widget                      | Browser           | Yes           | HMAC or customer session |
+| `@cstar.help/js/library`   | Public knowledge base                     | Browser or server | No            | None                     |
+| `@cstar.help/js/community` | Public community forum                    | Browser or server | No            | None                     |
+| `@cstar.help/js/webhook`   | Webhook signature verification            | Server only       | No            | Signing secret           |
+| `@cstar.help/js/auth`      | Authentication utilities                  | Server only       | Yes           | Secret (`sk_*`)          |
 
 ### The Security Model
 
-cStar uses **two key types** to control access — the same pattern as Stripe:
+The server API and customer chat authenticate differently:
 
-```
-Secret keys (sk_live_*, sk_test_*)
-├── Full CRUD on all resources
-├── Settings, billing, analytics, game system
-├── Team member management, audit log
-├── AI actions, automations, SLA rules
-└── NEVER expose in client-side code
-
-Publishable keys (pk_live_*, pk_test_*)
-├── Read-only on public data (tickets, customers, articles)
-├── Used by the chat widget for customer-facing features
-├── Safe to include in browser bundles
-└── Cannot write, delete, or access sensitive endpoints
-```
+- **Secret API keys** (`sk_live_*`, `sk_test_*`) authorize team API operations within the key's permissions. Keep them on your server.
+- **Publishable API keys** (`pk_live_*`, `pk_test_*`) provide limited read-only access to API endpoints that accept them. They do not identify a customer or authorize customer chat.
+- **ChatClient** takes a `teamSlug`, then authenticates a customer through HMAC identity verification or a customer session. It has no API-key option. Keep HMAC signing secrets on your server too.
 
-> **Rule of thumb**: If you're building a custom support dashboard for your team, use `CStarClient` with a secret key on your backend. If you're adding chat to your website, use `ChatClient` with a publishable key in the browser.
+> Building a support dashboard? Use `CStarClient` on your backend. Adding a conversation to your website? Use `ChatClient` and one of the customer authentication options below.
 
 ---
 
@@ -198,59 +187,95 @@ const { data: searchResults } = await cstar.search.query({
 
 ## Client-Side: Chat Widget SDK
 
-Build custom chat experiences in the browser. Uses a publishable key — safe for frontend code.
+Build a chat experience that feels at home on your site. `ChatClient` handles customer conversations in the browser without a team API key.
 
 The chat client supports two authentication modes:
 
-- **HMAC** — your server signs the customer payload with the team's signing secret. Best for sites where users are already authenticated server-side.
-- **Session** — the customer signs in directly with email/password (or magic link). Best for standalone widgets and customer portals where there's no host-app session to bridge.
+- **HMAC:** your authenticated backend signs the customer's identity with the team's signing secret. Use this when your site already knows who's signed in.
+- **Session:** sign in with cStar customer credentials, or provide an existing cStar customer access token. Use this for a standalone widget or customer portal.
 
-You don't have to pick the mode up-front. The first response from any cstar endpoint includes an `X-Cstar-Auth-Mode` header, which the SDK caches; `chat.getAuthMode()` returns `'hmac'`, `'session'`, or `null` after the first call.
+Choose the flow supported by your team's widget configuration. `chat.getAuthMode()` returns `'hmac'`, `'session'`, or `null` before authentication or after disconnecting. A session login sets the session mode; the SDK also reads the server's `X-Cstar-Auth-Mode` response header.
 
 ### HMAC
 
+Create `/api/support/identity` on your own backend. It must derive the customer from the authenticated user and return `{ customer, signature }` using your team's signing secret. Send that exact payload to cStar; generating a new timestamp in the browser changes the signed data. The [identity guide](https://cstar.help/developers/sdk/js/chat#identify) shows the signing contract.
+
 ```typescript
-import { ChatClient } from '@cstar.help/js/chat';
+import { ChatClient, type IdentifyParams } from '@cstar.help/js/chat';
 
 const chat = new ChatClient({ teamSlug: 'acme' });
-
-await chat.identify(
-	{ externalId: 'usr_123', email: 'jane@example.com', name: 'Jane', timestamp: Date.now() / 1000 },
-	hmacSignature
-);
+const response = await fetch('/api/support/identity', { credentials: 'same-origin' });
+if (!response.ok) throw new Error('Could not verify your support identity');
+
+const { customer, signature } = (await response.json()) as {
+	customer: IdentifyParams;
+	signature: string;
+};
+await chat.identify(customer, signature);
 ```
 
 ### Session (email/password)
 
 ```typescript
+import { ChatClient } from '@cstar.help/js/chat';
+
 const chat = new ChatClient({ teamSlug: 'acme' });
 
-// Login with credentials — returns the customer + tokens
-const { customer, accessToken, refreshToken } = await chat.loginWithCredentials(
-	'jane@example.com',
-	'hunter2'
-);
+// Use the values from your customer's sign-in form.
+const { customer, teamId } = await chat.loginWithCredentials({
+	email: 'jane@example.com',
+	password: 'your-customer-password'
+});
+console.log(`Hello, ${customer.name ?? customer.email}!`, teamId);
+```
+
+The client keeps the access token internally. The public result contains `customer` and `teamId`, not access or refresh tokens. This signs in an existing customer; it does not create an account.
+
+### Session (existing customer token)
+
+Pass an existing cStar customer token as an object. A token from an unrelated Supabase project does not establish a cStar customer session. Include the cStar team UUID when your application has it. Otherwise the client resolves its configured team slug before message, community and realtime requests.
 
-// Or rehydrate from previously stored tokens
-await chat.loginWithSession(accessToken, refreshToken);
+```typescript
+import { ChatClient, type LoginWithSessionParams } from '@cstar.help/js/chat';
+
+async function connectCustomerSession(session: LoginWithSessionParams) {
+	const chat = new ChatClient({ teamSlug: 'acme' });
+	await chat.loginWithSession(session); // { accessToken, teamId?, customerName? }
+	return chat;
+}
 ```
 
 ### Once authenticated (either mode)
 
 ```typescript
-const { tickets } = await chat.tickets.list();
-await chat.messages.send('tkt_abc123', 'Thanks for the help!');
-
-const unsubscribe = chat.onMessage('tkt_abc123', (message) => {
-	console.log(`${message.sender_name}: ${message.content}`);
-});
+const { data: tickets, pagination } = await chat.tickets.list();
+console.log(`${tickets.length} conversations`, pagination.hasMore);
+
+// Use a ticket ID returned by the customer API.
+const ticket = tickets[0];
+let unsubscribe = () => {};
+if (ticket) {
+	const history = await chat.messages.list(ticket.id);
+	console.log(history); // Message[]
+	await chat.messages.send(ticket.id, 'Thanks for the help!');
+
+	unsubscribe = chat.onMessage(ticket.id, (message) => {
+		console.log(`${message.sender_name}: ${message.content}`);
+	});
+}
 
-chat.disconnect();
+// Wire this to your UI's close/unmount handler and account-change cleanup.
+function closeChat() {
+	unsubscribe();
+	chat.disconnect();
+}
 ```
 
 ### Typed errors
 
-Every `ChatClient` request throws a typed subclass of `ChatClientError` on failure. Each carries a `requestId` (from the `X-Request-Id` response header) so customer support can correlate against server logs.
+HTTP and network failures use typed subclasses of `ChatClientError`. A server response may provide a `requestId` through the `X-Request-Id` header; it is `null` when unavailable. Other failures, such as malformed response JSON, can still throw ordinary errors.
+
+A lost response may follow a successful send. Keep the unsent text available and check the conversation before offering another send. Do not automatically resend a message because a network or server error occurred.
 
 ```typescript
 import {
@@ -265,15 +290,17 @@ try {
 	await chat.identify(customer, signature);
 } catch (err) {
 	if (err instanceof ChatClientAuthError) {
-		// 401 / 403 — bad signature, expired token, wrong team
+		// Authentication failed or the active customer session changed.
 	} else if (err instanceof ChatClientRateLimitError) {
-		// 429 — back off for err.retryAfter seconds
+		// 429: respect err.retryAfter when the server supplies it.
 	} else if (err instanceof ChatClientServerError) {
-		// 5xx — usually transient, retry with backoff
+		// Server failure: keep the draft and check the conversation.
 	} else if (err instanceof ChatClientNetworkError) {
-		// fetch() itself failed — DNS, offline, CORS — see err.originalError
+		// Network failure: err.originalError has the underlying cause.
 	} else if (err instanceof ChatClientError) {
 		console.log('Error', err.code, err.statusCode, 'requestId:', err.requestId);
+	} else {
+		throw err;
 	}
 }
 ```
@@ -349,11 +376,24 @@ const cstar = new CStarClient({
 	teamId: 'tm_...', // Required — your team ID
 	baseUrl: 'https://...', // Optional — defaults to https://www.cstar.help
 	version: '2026-03-01', // Optional — API version header
-	maxRetries: 3, // Optional — retry attempts for 5xx/429
+	maxRetries: 3, // Optional — retry attempts for retry-safe failures and 429
 	timeout: 30000 // Optional — request timeout in ms
 });
 ```
 
+Reads retry network errors and server errors automatically. POST and PATCH
+requests retry those failures only when you pass `idempotencyKey` in the existing
+request options. A lost response may follow a successful write, so the SDK
+otherwise surfaces the error without repeating the mutation. Rate-limited
+requests still retry because the API rejects them before executing the operation.
+
+```typescript
+await cstar.tickets.create(
+	{ title: 'Cannot reset password', customerId: 'cus_...' },
+	{ idempotencyKey: 'support-issue-123' }
+);
+```
+
 ## Test Mode
 
 Test mode is auto-detected from your API key prefix:
@@ -411,7 +451,7 @@ const { data: ticket } = await cstar.tickets.create(
 
 ## Requirements
 
-- Node.js 18+ (for native `fetch` and `AbortSignal.timeout`)
+- Node.js 22+ (matching the supported Supabase dependency)
 - TypeScript 5.0+ (for type definitions)
 
 ## License

package/dist/auth/index.d.cts

@@ -1,3 +1,5 @@
+export { A as ApiErrorBody, C as CStarAuthenticationError, a as CStarConflictError, b as CStarError, c as CStarFeatureDisabledError, d as CStarNotFoundError, e as CStarPermissionError, f as CStarRateLimitError, g as CStarRealtimeUnavailableError, h as CStarServerError, i as CStarValidationError, E as ErrorType, p as parseError, j as parsePublicError } from '../errors-b5A4wfAg.cjs';
+
 /** Configuration for the AuthClient. */
 interface AuthConfig {
     /** Team slug (e.g., 'acme'). Identifies which team's customers to authenticate. */
@@ -56,403 +58,6 @@ interface AuthSession {
     refreshToken: string;
 }
 
-/**
- * Error classes for the cStar SDK.
- *
- * NEW-v3-01 — Cross-subpath instanceof identity.
- *
- * Each public subpath (`/library`, `/auth`, `/community`, `/quickhelp`, ...)
- * is bundled as a separate tsup entry with `splitting: false`, so each one
- * carries its own copy of this module. Without deduplication, errors thrown
- * by `LibraryClient` carry the LibraryClient-bundled `CStarError` class —
- * not the one a consumer imports from `@cstar.help/js`. That makes
- * `instanceof CStarError` checks fail silently, invalidating every "did the
- * SDK throw a typed cStar error?" branch in user code.
- *
- * Fix: register each class on a `Symbol.for(...)` slot of `globalThis`. The
- * symbol is realm-shared, so every bundled copy of this module resolves to
- * the SAME class identity at runtime — the first copy to load wins, and all
- * subsequent copies surface the canonical class via the same slot. The
- * inline `Impl` definitions are only used as the seed for the very first
- * copy to register. Internal `parseError` / `parsePublicError` reference the
- * EXPORTED canonical names so instances they construct also land on the
- * canonical class.
- */
-/** Error type constants matching the cStar API. */
-declare const ErrorType: {
-    readonly AUTHENTICATION_ERROR: "authentication_error";
-    readonly PERMISSION_ERROR: "permission_error";
-    readonly INVALID_REQUEST_ERROR: "invalid_request_error";
-    readonly NOT_FOUND_ERROR: "not_found_error";
-    readonly CONFLICT_ERROR: "conflict_error";
-    readonly RATE_LIMIT_ERROR: "rate_limit_error";
-    readonly FEATURE_NOT_CONFIGURED: "feature_not_configured";
-    readonly API_ERROR: "api_error";
-    readonly SERVER_ERROR: "server_error";
-};
-/** Shape of the error object returned by the cStar API. */
-interface ApiErrorBody {
-    type: string;
-    code: string;
-    message: string;
-    param?: string;
-    doc_url: string;
-    request_id?: string;
-    feature?: string;
-    enable_url?: string;
-}
-/** Base error class for all cStar API errors. */
-declare const CStarErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarAuthenticationErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarRateLimitErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody, retryAfter?: number): {
-        readonly retryAfter: number;
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarNotFoundErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarValidationErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarPermissionErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarConflictErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarServerErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarFeatureDisabledErrorImpl: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly feature: string;
-        readonly enableUrl: string;
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarRealtimeUnavailableErrorImpl: {
-    new (message?: string): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-declare const CStarError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarError = InstanceType<typeof CStarErrorImpl>;
-declare const CStarAuthenticationError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarAuthenticationError = InstanceType<typeof CStarAuthenticationErrorImpl>;
-declare const CStarRateLimitError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody, retryAfter?: number): {
-        readonly retryAfter: number;
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarRateLimitError = InstanceType<typeof CStarRateLimitErrorImpl>;
-declare const CStarNotFoundError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarNotFoundError = InstanceType<typeof CStarNotFoundErrorImpl>;
-declare const CStarValidationError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarValidationError = InstanceType<typeof CStarValidationErrorImpl>;
-declare const CStarPermissionError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarPermissionError = InstanceType<typeof CStarPermissionErrorImpl>;
-declare const CStarConflictError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarConflictError = InstanceType<typeof CStarConflictErrorImpl>;
-declare const CStarServerError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarServerError = InstanceType<typeof CStarServerErrorImpl>;
-declare const CStarFeatureDisabledError: {
-    new (messageOrStatus: string | number, body?: ApiErrorBody): {
-        readonly feature: string;
-        readonly enableUrl: string;
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarFeatureDisabledError = InstanceType<typeof CStarFeatureDisabledErrorImpl>;
-declare const CStarRealtimeUnavailableError: {
-    new (message?: string): {
-        readonly type: string;
-        readonly code: string;
-        readonly param?: string;
-        readonly docUrl: string;
-        readonly requestId?: string;
-        readonly statusCode: number;
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-type CStarRealtimeUnavailableError = InstanceType<typeof CStarRealtimeUnavailableErrorImpl>;
-/**
- * Parse a public-route response (anonymous LibraryClient, CommunityClient,
- * QuickHelpClient, AuthClient) into a typed `CStarError`.
- *
- * Public routes don't always emit the structured `{error: {type, code,
- * doc_url, ...}}` envelope — many emit `{error: 'message string'}` or
- * `{message: '...'}`. This helper normalizes both shapes and dispatches
- * on HTTP status (closes F-026 and F-034 — Library/Auth used to throw
- * plain `Error`).
- */
-declare function parsePublicError(status: number, body: unknown, fallbackMessage: string): CStarError;
-declare function parseError(statusCode: number, body: {
-    error?: ApiErrorBody;
-} | null, retryAfter?: number): CStarError;
-
 /**
  * Customer authentication client for the cStar widget API.
  *
@@ -517,4 +122,4 @@ declare class AuthClient {
     private fetch;
 }
 
-export { type ApiErrorBody, AuthClient, type AuthConfig, type AuthCustomer, type AuthSession, CStarAuthenticationError, CStarConflictError, CStarError, CStarFeatureDisabledError, CStarNotFoundError, CStarPermissionError, CStarRateLimitError, CStarRealtimeUnavailableError, CStarServerError, CStarValidationError, ErrorType, type LoginParams, type LoginResult, type SignupConfirmationResult, type SignupParams, type SignupResult, parseError, parsePublicError };
+export { AuthClient, type AuthConfig, type AuthCustomer, type AuthSession, type LoginParams, type LoginResult, type SignupConfirmationResult, type SignupParams, type SignupResult };