@cstar.help/js 0.12.1 → 0.14.0

package/dist/index.d.ts

@@ -0,0 +1,3287 @@
+/** Metadata: string key-value pairs. Max 50 keys, 40-char keys, 500-char values. */
+type Metadata = Record<string, string>;
+/** Standard pagination parameters accepted by list endpoints. */
+interface PaginationParams {
+    page?: number;
+    pageSize?: number;
+}
+/** Pagination info returned in list responses. */
+interface PaginationInfo {
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+}
+/**
+ * Resource response — unwrapped bare object.
+ *
+ * Closes F-016. The historical envelope (`{success, data, meta}`) is now
+ * unwrapped at the HTTP-client boundary so callers can `const t = await
+ * cstar.tickets.create(...); console.log(t.id)` instead of `t.data.id`.
+ *
+ * Side-channel access: read `client.lastMeta` immediately after a call to
+ * grab the server `requestId` for support escalations.
+ *
+ * Kept as a type alias rather than removed so existing user code that
+ * imports the name keeps compiling.
+ */
+type ApiResponse<T> = T;
+/**
+ * List response — unwrapped to `{data, pagination, hasMore}` (matches
+ * Stripe-style auto-pagination cursors but keeps server `pagination` info
+ * for callers who want totals).
+ */
+interface ListResponse<T> {
+    data: T[];
+    pagination: PaginationInfo;
+    /** Convenience: same as `pagination.hasMore`. */
+    hasMore: boolean;
+}
+/**
+ * Side-channel metadata from the most recent response. Mutable per-call,
+ * so read it immediately after the awaited call. Documented on every
+ * resource page as the way to grab `requestId` for support tickets.
+ */
+interface LastMeta {
+    requestId: string | null;
+    timestamp: string | null;
+    pagination: PaginationInfo | null;
+}
+/** Delete response body. */
+interface DeleteResponse {
+    deleted: true;
+    id: string;
+}
+/** Per-request options passed to resource methods. */
+interface RequestOptions {
+    /** Idempotency key for safe retries on POST/PATCH. */
+    idempotencyKey?: string;
+    /** Related resources to expand inline. */
+    expand?: string[];
+}
+
+/** Configuration for the HTTP client. */
+interface ClientConfig {
+    apiKey: string;
+    teamId: string;
+    baseUrl?: string;
+    version?: string;
+    maxRetries?: number;
+    timeout?: number;
+}
+/** Options for a single request. */
+interface FetchOptions {
+    body?: unknown;
+    query?: Record<string, string | string[] | number | boolean | undefined>;
+    idempotencyKey?: string;
+}
+/**
+ * Low-level HTTP client for the cStar API.
+ * Handles authentication, retries, rate limiting, and error parsing.
+ */
+declare class HttpClient {
+    private readonly config;
+    /** Whether this client uses test mode keys. */
+    readonly environment: 'live' | 'test';
+    /**
+     * Side-channel metadata from the most recent response. Holds the server
+     * `requestId`, `timestamp`, and (for list endpoints) `pagination`. Mutable
+     * per-call — read it immediately after awaiting the call.
+     *
+     * ```ts
+     * const ticket = await cstar.tickets.create({...});
+     * console.error('Created ticket', ticket.id, 'request:', cstar.lastMeta.requestId);
+     * ```
+     */
+    lastMeta: LastMeta;
+    constructor(config: ClientConfig);
+    /**
+     * Make an authenticated request to the cStar API.
+     * Automatically retries on 5xx errors and rate limits.
+     */
+    request<T>(method: string, path: string, options?: FetchOptions): Promise<T>;
+    /**
+     * Like `request()` but skips the `/api/v1/teams/{teamId}` prefix. Used for
+     * the small set of non-team-scoped endpoints (`/auth/whoami`, etc).
+     *
+     * @internal — exposed to CStarClient for `whoami()` and similar; not part
+     * of the documented public surface.
+     */
+    requestUnscoped<T>(method: string, path: string, options?: FetchOptions): Promise<T>;
+    private appendQuery;
+    private _sendRequest;
+    /**
+     * Capture `meta`, `requestId`, and `pagination` from the raw response
+     * into `this.lastMeta` before unwrapping the envelope.
+     */
+    private captureMeta;
+    /**
+     * Unwrap the legacy `{success, data, meta, pagination?}` envelope.
+     * - `{success:true, data: array, pagination}` → `{data, pagination, hasMore}`
+     * - `{success:true, data: object}` → `data` (bare resource)
+     * - other shapes pass through unchanged so subpath SDKs (chat, library) keep
+     *   their bespoke shapes for now.
+     */
+    private unwrapEnvelope;
+    private buildUrl;
+    private buildHeaders;
+    /** Get the base URL for building SSE or other endpoints. */
+    getBaseUrl(): string;
+    /** Get authorization headers for non-fetch requests (e.g., SSE). */
+    getAuthHeaders(): Record<string, string>;
+    /** Exponential backoff: 500ms, 1s, 2s, 4s... capped at 8s, plus jitter. */
+    private getBackoffDelay;
+    private sleep;
+}
+
+/**
+ * The subset of the global `EventSource` constructor surface that the
+ * realtime client uses. Allows polyfill injection (e.g. the `eventsource`
+ * npm package on Node) without forcing the polyfill to satisfy the full
+ * lib.dom.d.ts shape.
+ */
+type EventSourceConstructor = new (url: string) => EventSource;
+/** Options for configuring the realtime connection. */
+interface RealtimeOptions {
+    /** Event types to subscribe to (e.g., ['ticket.*', 'boss.*']). Omit for all. */
+    types?: string[];
+    /** Auto-reconnect on disconnect (default: true). */
+    autoReconnect?: boolean;
+    /** Max reconnection attempts before giving up (default: 10). */
+    maxRetries?: number;
+    /**
+     * EventSource constructor to use. Defaults to `globalThis.EventSource`
+     * (browsers and Node 22+). Pass an explicit polyfill (e.g. the
+     * `eventsource` npm package) to subscribe from a Node environment that
+     * lacks the global. Closes NEW-v2-02.
+     */
+    eventSource?: EventSourceConstructor;
+}
+/** A parsed realtime event from the SSE stream. */
+interface RealtimeEvent<T = unknown> {
+    /** Event type (e.g., 'ticket.created'). */
+    type: string;
+    /** Unique event ID for reconnection. */
+    id: string;
+    /** Typed event payload. */
+    data: T;
+    /** ISO-8601 timestamp. */
+    timestamp: string;
+    /** Team ID that owns this event. */
+    teamId: string;
+}
+type EventHandler<T = unknown> = (event: RealtimeEvent<T>) => void;
+type ErrorHandler = (error: Error) => void;
+type ConnectionHandler = (connected: boolean) => void;
+/**
+ * SSE-based realtime client for the cStar API.
+ *
+ * Manages a single EventSource connection to `/events/stream` and dispatches
+ * events to registered handlers. Supports wildcard matching (e.g., `ticket.*`),
+ * auto-reconnection with exponential backoff, and reconnection replay via
+ * `Last-Event-ID`.
+ */
+declare class CStarRealtime {
+    private readonly httpClient;
+    private eventSource;
+    private handlers;
+    private anyHandlers;
+    private errorHandlers;
+    private connectionHandlers;
+    private lastEventId;
+    private retryCount;
+    private retryTimer;
+    private _connected;
+    private destroyed;
+    private connecting;
+    /** Short-lived SSE token (exchanged from secret key). */
+    private sseToken;
+    /** When the current SSE token expires (epoch ms). */
+    private sseTokenExpiresAt;
+    /** Timer that refreshes the SSE token before it expires. */
+    private tokenRefreshTimer;
+    private readonly autoReconnect;
+    private readonly maxRetries;
+    private readonly types;
+    private readonly eventSourceCtor;
+    constructor(httpClient: HttpClient, options?: RealtimeOptions);
+    /**
+     * Resolve the EventSource constructor to use for this connection.
+     * Returns the explicit polyfill when one was injected, otherwise the
+     * global. Returns `undefined` when neither is available — callers must
+     * convert to `CStarRealtimeUnavailableError` before touching it.
+     */
+    private resolveEventSource;
+    /** Subscribe to a specific event type. Supports wildcards (e.g., 'ticket.*'). Returns an unsubscribe function. */
+    on<T = unknown>(eventType: string, handler: EventHandler<T>): () => void;
+    /** Subscribe to all events. Returns an unsubscribe function. */
+    onAny<T = unknown>(handler: EventHandler<T>): () => void;
+    /** Handle connection errors. */
+    onError(handler: ErrorHandler): this;
+    /** Handle connection state changes. */
+    onConnectionChange(handler: ConnectionHandler): this;
+    /** Remove a connection state handler. */
+    offConnectionChange(handler: ConnectionHandler): this;
+    /** Remove a handler for a specific event type. */
+    off<T = unknown>(eventType: string, handler: EventHandler<T>): this;
+    /** Remove a handler from the "any" subscription. */
+    offAny<T = unknown>(handler: EventHandler<T>): this;
+    /** Start the SSE connection. Called automatically on first handler registration. */
+    connect(): void;
+    /**
+     * Open the EventSource with the given auth token.
+     * Extracted so both the happy path and the fallback path share logic.
+     */
+    private connectWithToken;
+    /** Stop listening and clean up all resources. */
+    disconnect(): void;
+    /** Whether the SSE connection is currently open. */
+    get connected(): boolean;
+    private ensureConnected;
+    private handleMessage;
+    private dispatch;
+    private scheduleReconnect;
+    private setConnected;
+    private emitError;
+    /** Whether we hold a token that won't expire for at least 30 seconds. */
+    private hasFreshSseToken;
+    /**
+     * Exchange the secret API key for a short-lived SSE token via
+     * POST /events/token. Schedules automatic refresh before expiry.
+     */
+    private exchangeToken;
+    /**
+     * Schedule a background token refresh. On success the existing connection
+     * keeps working (tokens are validated at connect time). On the next
+     * reconnect the fresh token will be used automatically.
+     */
+    private scheduleTokenRefresh;
+}
+
+/** A message on a ticket. */
+interface Message {
+    id: string;
+    object: 'message';
+    sender: 'customer' | 'agent' | 'system';
+    content: string;
+    senderId: string | null;
+    senderName: string | null;
+    senderAvatarUrl: string | null;
+    createdAt: string;
+    mergedFromShortId: string | null;
+}
+/** Parameters for creating a message on a ticket. */
+interface MessageCreateParams {
+    content: string;
+    sender?: 'customer' | 'agent' | 'system';
+    senderId?: string;
+    senderName?: string;
+}
+
+/** A cStar support ticket. */
+interface Ticket {
+    id: string;
+    object: 'ticket';
+    title: string;
+    priority: 'low' | 'normal' | 'high' | 'urgent';
+    status: string;
+    customerId: string | null;
+    customerName: string | null;
+    assignedTo: string | null;
+    tags: string[];
+    notes: string | null;
+    messageCount: number;
+    responseDeadline: string | null;
+    resolutionDeadline: string | null;
+    firstResponseAt: string | null;
+    responseTier: string | null;
+    resolutionTier: string | null;
+    slaPaused: boolean;
+    metadata: Metadata;
+    createdAt: string;
+    closedAt: string | null;
+    updatedAt: string;
+    /** Present when expand includes 'messages' or on single-ticket GET. */
+    messages?: Message[];
+    /** Present when expand includes 'customer'. */
+    customer?: TicketCustomerSummary | null;
+}
+/** Inline customer summary when expanding on a ticket. */
+interface TicketCustomerSummary {
+    id: string;
+    object: 'customer';
+    name: string;
+    email: string;
+    sentiment: string;
+    status: string;
+}
+/** Parameters for listing tickets. */
+interface TicketListParams extends PaginationParams {
+    status?: string;
+    priority?: 'low' | 'normal' | 'high' | 'urgent';
+    customerId?: string;
+    assignedTo?: string;
+    search?: string;
+    expand?: string[];
+}
+/** Parameters for creating a ticket. */
+interface TicketCreateParams {
+    title: string;
+    priority?: 'low' | 'normal' | 'high' | 'urgent';
+    status?: string;
+    customerId?: string;
+    customerName?: string;
+    tags?: string[];
+    notes?: string;
+    metadata?: Metadata;
+}
+/** Parameters for updating a ticket. */
+interface TicketUpdateParams {
+    title?: string;
+    priority?: 'low' | 'normal' | 'high' | 'urgent';
+    status?: string;
+    customerId?: string | null;
+    customerName?: string;
+    assignedTo?: string | null;
+    tags?: string[];
+    notes?: string;
+    metadata?: Record<string, string | null>;
+}
+
+type ChangeHandler<T> = (data: T[]) => void;
+type ErrorEventHandler = (error: Error) => void;
+declare class Subscription$1<T = unknown> {
+    private readonly realtime;
+    private readonly fetchFn;
+    private readonly resourcePath;
+    private readonly filterFn?;
+    private _data;
+    private _loading;
+    private _error;
+    private changeHandlers;
+    private errorEventHandlers;
+    private boundEventHandler;
+    private destroyed;
+    /** Generation counter to prevent stale refresh() from overwriting SSE updates. */
+    private generation;
+    constructor(realtime: CStarRealtime, fetchFn: () => Promise<ListResponse<T>>, resourcePath: string, filterFn?: ((item: T) => boolean) | undefined);
+    /** Current data array (updated in real-time). */
+    get data(): T[];
+    /** True during initial data fetch. */
+    get loading(): boolean;
+    /** Last error, if any. */
+    get error(): Error | null;
+    /** Register a callback for data changes or errors. */
+    on(event: 'change', handler: ChangeHandler<T>): this;
+    on(event: 'error', handler: ErrorEventHandler): this;
+    /** Manually refresh data from the server. */
+    refresh(): Promise<void>;
+    /**
+     * Apply an optimistic update to the local data.
+     * Returns a rollback function that reverts the change.
+     */
+    optimisticUpdate(id: string, changes: Partial<T>): () => void;
+    /** Stop the subscription and clean up all listeners. */
+    unsubscribe(): void;
+    private init;
+    private handleEvent;
+    private handleCreated;
+    private handleDeleted;
+    private handleUpdated;
+    private extractEntity;
+    private emitChange;
+    private emitError;
+}
+
+/**
+ * Base resource class implementing standard CRUD operations.
+ * Resource-specific classes extend this with their own type parameters.
+ *
+ * As of 0.13.0 every method returns the unwrapped resource (or unwrapped
+ * `{data, pagination, hasMore}` for list endpoints). Closes F-016. Read
+ * `client.lastMeta.requestId` for the server request ID.
+ */
+declare abstract class BaseResource<TEntity, TListParams extends PaginationParams, TCreateParams, TUpdateParams> {
+    protected readonly client: HttpClient;
+    protected readonly basePath: string;
+    constructor(client: HttpClient, basePath: string);
+    /** List resources with optional filtering and pagination. */
+    list(params?: TListParams & RequestOptions): Promise<ListResponse<TEntity>>;
+    /** Get a single resource by ID. */
+    get(id: string, options?: RequestOptions): Promise<TEntity>;
+    /** Create a new resource. */
+    create(params: TCreateParams, options?: RequestOptions): Promise<TEntity>;
+    /** Update an existing resource. */
+    update(id: string, params: TUpdateParams, options?: RequestOptions): Promise<TEntity>;
+    /** Delete a resource by ID. */
+    del(id: string): Promise<DeleteResponse>;
+    /**
+     * Delete a resource by ID. Alias for `del()` — kept because IDE
+     * auto-complete and documentation both surface `delete` first. Closes
+     * NEW-v2-06.
+     */
+    delete(id: string): Promise<DeleteResponse>;
+    /**
+     * Auto-paginating async iterator that yields every item across all pages.
+     *
+     * ```typescript
+     * for await (const ticket of cstar.tickets.listAutoPaginating({ status: 'open' })) {
+     *   console.log(ticket.title);
+     * }
+     * ```
+     */
+    listAutoPaginating(params?: Omit<TListParams, 'page'> & RequestOptions): AsyncIterable<TEntity>;
+    /**
+     * Subscribe to real-time changes for this resource type.
+     *
+     * Fetches initial data, then auto-updates via SSE events.
+     * Requires a `CStarRealtime` instance (available from `CStarClient.realtime`).
+     *
+     * ```typescript
+     * const sub = cstar.tickets.subscribe(cstar.realtime, { status: 'open' });
+     * sub.on('change', (tickets) => console.log(tickets));
+     * // Later: sub.unsubscribe();
+     * ```
+     */
+    subscribe(realtime: CStarRealtime, params?: TListParams & RequestOptions, filterFn?: (item: TEntity) => boolean): Subscription$1<TEntity>;
+    /** Convert params to string values for query string serialization. */
+    protected serializeQuery(params: Record<string, unknown>): Record<string, string | string[] | undefined>;
+}
+
+/** Manage ticket messages as a sub-resource. */
+declare class TicketMessagesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List all messages on a ticket. */
+    list(ticketId: string): Promise<ListResponse<Message>>;
+    /** Add a message to a ticket. */
+    create(ticketId: string, params: MessageCreateParams, options?: RequestOptions): Promise<Message>;
+}
+/** Manage support tickets. */
+declare class TicketsResource extends BaseResource<Ticket, TicketListParams, TicketCreateParams, TicketUpdateParams> {
+    /** Sub-resource for ticket messages. */
+    readonly messages: TicketMessagesResource;
+    constructor(client: HttpClient);
+}
+
+/** A cStar customer. */
+interface Customer {
+    id: string;
+    object: 'customer';
+    name: string;
+    email: string;
+    sentiment: string;
+    status: string;
+    tags: string[];
+    notes: string | null;
+    customFields: Record<string, unknown>;
+    ticketCount: number;
+    metadata: Metadata;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for listing customers. */
+interface CustomerListParams extends PaginationParams {
+    status?: string;
+    sentiment?: string;
+    search?: string;
+    tag?: string;
+    expand?: string[];
+}
+/** Parameters for creating a customer. */
+interface CustomerCreateParams {
+    name: string;
+    email: string;
+    sentiment?: string;
+    status?: string;
+    tags?: string[];
+    notes?: string;
+    customFields?: Record<string, unknown>;
+    metadata?: Metadata;
+}
+/** Parameters for updating a customer. */
+interface CustomerUpdateParams {
+    name?: string;
+    email?: string;
+    sentiment?: string;
+    status?: string;
+    tags?: string[];
+    notes?: string;
+    customFields?: Record<string, unknown>;
+    metadata?: Record<string, string | null>;
+}
+
+/** Manage customers. */
+declare class CustomersResource extends BaseResource<Customer, CustomerListParams, CustomerCreateParams, CustomerUpdateParams> {
+    constructor(client: HttpClient);
+}
+
+/** A cStar knowledge base article. */
+interface Article {
+    id: string;
+    object: 'article';
+    title: string;
+    slug: string | null;
+    excerpt: string | null;
+    content: string | null;
+    categoryId: string | null;
+    status: 'draft' | 'published';
+    tags: string[];
+    notes: string | null;
+    viewCount: number;
+    useCount: number;
+    readTime: string;
+    isPublic: boolean;
+    publishedAt: string | null;
+    metaDescription: string | null;
+    metadata: Metadata;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for listing articles. */
+interface ArticleListParams extends PaginationParams {
+    category?: string;
+    status?: 'draft' | 'published';
+    isPublic?: boolean;
+    search?: string;
+    tag?: string;
+    expand?: string[];
+}
+/** Parameters for creating an article. */
+interface ArticleCreateParams {
+    title: string;
+    content?: string;
+    excerpt?: string;
+    categoryId?: string;
+    status?: 'draft' | 'published';
+    tags?: string[];
+    notes?: string;
+    isPublic?: boolean;
+    slug?: string;
+    metaDescription?: string;
+    metadata?: Metadata;
+}
+/** Parameters for updating an article. */
+interface ArticleUpdateParams {
+    title?: string;
+    content?: string;
+    excerpt?: string;
+    categoryId?: string;
+    status?: 'draft' | 'published';
+    tags?: string[];
+    notes?: string;
+    isPublic?: boolean;
+    slug?: string;
+    metaDescription?: string;
+    metadata?: Record<string, string | null>;
+}
+
+/** Manage knowledge base articles. */
+declare class ArticlesResource extends BaseResource<Article, ArticleListParams, ArticleCreateParams, ArticleUpdateParams> {
+    constructor(client: HttpClient);
+}
+
+/** Every webhook event type cStar can dispatch. */
+type WebhookEventType = 'article.created' | 'article.deleted' | 'article.published' | 'article.updated' | 'boss.damaged' | 'boss.defeated' | 'boss.spawned' | 'community_post.commented' | 'community_post.created' | 'community_post.deleted' | 'community_post.status_changed' | 'community_post.updated' | 'community_post.voted' | 'customer.created' | 'customer.deleted' | 'customer.updated' | 'customer_group.created' | 'customer_group.deleted' | 'customer_group.updated' | 'player.achievement_unlocked' | 'player.level_up' | 'player.quest_completed' | 'player.streak_milestone' | 'player.xp_gained' | 'social.high_five_sent' | 'social.one_up_sent' | 'survey.submitted' | 'ticket.assigned' | 'ticket.closed' | 'ticket.created' | 'ticket.deleted' | 'ticket.message_added' | 'ticket.updated';
+/** Payload for `article.created` events. */
+interface ArticleCreatedPayload {
+    article: {
+        id: string;
+        title: string;
+        slug: string;
+        is_public: boolean;
+        created_at: string;
+    };
+}
+/** Payload for `article.deleted` events. */
+interface ArticleDeletedPayload {
+    id: string;
+}
+/** Payload for `article.published` events. */
+interface ArticlePublishedPayload {
+    article: {
+        id: string;
+        title: string;
+        slug: string;
+        is_public: boolean;
+        published_at: string;
+    };
+}
+/** Payload for `article.updated` events. */
+interface ArticleUpdatedPayload {
+    article: {
+        id: string;
+        title: string;
+        slug: string;
+        is_public: boolean;
+    };
+}
+/** Payload for `boss.damaged` events. */
+interface BossDamagedPayload {
+    boss: {
+        id: string;
+        current_hp: number;
+    };
+    damage: number;
+    by: {
+        agent_id: string;
+        name: string;
+    };
+}
+/** Payload for `boss.defeated` events. */
+interface BossDefeatedPayload {
+    boss: {
+        id: string;
+        name: string;
+    };
+    final_blow_by: {
+        agent_id: string;
+        name: string;
+    };
+    team_xp_awarded: number;
+}
+/** Payload for `boss.spawned` events. */
+interface BossSpawnedPayload {
+    boss: {
+        id: string;
+        name: string;
+        level: number;
+        max_hp: number;
+    };
+}
+/** Payload for `community_post.commented` events. */
+interface CommunityPostCommentedPayload {
+    comment: {
+        id: string;
+        post_id: string;
+        content: string;
+        author_id: string;
+        created_at: string;
+    };
+}
+/** Payload for `community_post.created` events. */
+interface CommunityPostCreatedPayload {
+    post: {
+        id: string;
+        prefixed_id: string;
+        title: string;
+        status: string;
+        visibility: string;
+        topic: string;
+        created_at: string;
+    };
+}
+/** Payload for `community_post.deleted` events. */
+interface CommunityPostDeletedPayload {
+    post: {
+        id: string;
+        prefixed_id?: string;
+        title?: string;
+    };
+}
+/** Payload for `community_post.status_changed` events. */
+interface CommunityPostStatusChangedPayload {
+    post: {
+        id: string;
+        title: string;
+        status: string;
+        visibility: string;
+    };
+}
+/** Payload for `community_post.updated` events. */
+interface CommunityPostUpdatedPayload {
+    post: {
+        id: string;
+        title: string;
+        status: string;
+        visibility: string;
+    };
+}
+/** Payload for `community_post.voted` events. */
+interface CommunityPostVotedPayload {
+    post: {
+        id: string;
+        vote_count: number;
+    };
+    voter: {
+        id: string;
+    };
+    direction: string;
+}
+/** Payload for `customer.created` events. */
+interface CustomerCreatedPayload {
+    customer: {
+        id: string;
+        name: string;
+        email: string;
+        status: string;
+        tags: Array<string>;
+        created_at: string;
+    };
+}
+/** Payload for `customer.deleted` events. */
+interface CustomerDeletedPayload {
+    id: string;
+}
+/** Payload for `customer.updated` events. */
+interface CustomerUpdatedPayload {
+    customer: {
+        id: string;
+        name: string;
+        email: string;
+        status: string;
+        tags: Array<string>;
+    };
+    changes: {
+        tags: {
+            from: Array<string>;
+            to: Array<string>;
+        };
+    };
+}
+/** Payload for `customer_group.created` events. */
+interface CustomerGroupCreatedPayload {
+    group: {
+        id: string;
+        name: string;
+        color: string;
+        member_count: number;
+    };
+}
+/** Payload for `customer_group.deleted` events. */
+interface CustomerGroupDeletedPayload {
+    customer_group: {
+        id: string;
+    };
+}
+/** Payload for `customer_group.updated` events. */
+interface CustomerGroupUpdatedPayload {
+    group: {
+        id: string;
+        name: string;
+        color: string;
+        member_count: number;
+    };
+}
+/** Payload for `player.achievement_unlocked` events. */
+interface PlayerAchievementUnlockedPayload {
+    player: {
+        agent_id: string;
+        name: string;
+    };
+    achievement: {
+        id: string;
+        name: string;
+        xp: number;
+    };
+}
+/** Payload for `player.level_up` events. */
+interface PlayerLevelUpPayload {
+    player: {
+        agent_id: string;
+        name: string;
+    };
+    level: {
+        from: number;
+        to: number;
+    };
+    title_unlocked: string;
+}
+/** Payload for `player.quest_completed` events. */
+interface PlayerQuestCompletedPayload {
+    player: {
+        agent_id: string;
+        name: string;
+    };
+    quest: {
+        id: string;
+        name: string;
+        xp: number;
+    };
+}
+/** Payload for `player.streak_milestone` events. */
+interface PlayerStreakMilestonePayload {
+    player: {
+        agent_id: string;
+        name: string;
+    };
+    streak_days: number;
+    milestone: number;
+}
+/** Payload for `player.xp_gained` events. */
+interface PlayerXpGainedPayload {
+    player: {
+        agent_id: string;
+        name: string;
+    };
+    amount: number;
+    reason: string;
+    ticket_id: string;
+}
+/** Payload for `social.high_five_sent` events. */
+interface SocialHighFiveSentPayload {
+    from_team: {
+        id: string;
+        name: string;
+    };
+    to_team: {
+        id: string;
+        name: string;
+    };
+    message: string;
+}
+/** Payload for `social.one_up_sent` events. */
+interface SocialOneUpSentPayload {
+    from: {
+        agent_id: string;
+        name: string;
+    };
+    to: {
+        agent_id: string;
+        name: string;
+    };
+    ticket_id: string;
+    message: string;
+}
+/** Payload for `survey.submitted` events. */
+interface SurveySubmittedPayload {
+    survey: {
+        id: string;
+        ticket_id: string;
+        score: number;
+        comment: string;
+        submitted_at: string;
+    };
+    customer: {
+        id: string;
+        email: string;
+    };
+}
+/** Payload for `ticket.assigned` events. */
+interface TicketAssignedPayload {
+    ticket: {
+        id: string;
+        prefixed_id: string;
+    };
+    assignee: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    previous_assignee: null;
+}
+/** Payload for `ticket.closed` events. */
+interface TicketClosedPayload {
+    ticket: {
+        id: string;
+        prefixed_id: string;
+        title: string;
+        status: string;
+        priority: string;
+        channel: string;
+        resolved_at: string;
+    };
+    changes?: Record<string, {
+        from: string;
+        to: string;
+    }>;
+}
+/** Payload for `ticket.created` events. */
+interface TicketCreatedPayload {
+    ticket: {
+        id: string;
+        prefixed_id: string;
+        title: string;
+        status: string;
+        priority: string;
+        channel: string;
+        customer_id: string;
+        created_at: string;
+    };
+    customer: {
+        id: string;
+        name: string;
+        email: string;
+    };
+}
+/** Payload for `ticket.deleted` events. */
+interface TicketDeletedPayload {
+    id: string;
+}
+/** Payload for `ticket.message_added` events. */
+interface TicketMessageAddedPayload {
+    ticket: {
+        id: string;
+        dashboard_url: string | null;
+    };
+    message: {
+        id: string;
+        sender: string;
+        sender_name: string | null;
+        content: string;
+        created_at: string;
+    };
+    customer?: {
+        id: string;
+        name: string | null;
+        email: string | null;
+    };
+}
+/** Payload for `ticket.updated` events. */
+interface TicketUpdatedPayload {
+    ticket: {
+        id: string;
+        prefixed_id: string;
+        title: string;
+        status: string;
+        priority: string;
+        channel: string;
+    };
+    changes?: Record<string, {
+        from: string;
+        to: string;
+    } | {
+        from: Array<string>;
+        to: Array<string>;
+    }>;
+}
+/** Maps each event type to its payload interface — used internally for the discriminated union. */
+interface WebhookEventDataMap {
+    'article.created': ArticleCreatedPayload;
+    'article.deleted': ArticleDeletedPayload;
+    'article.published': ArticlePublishedPayload;
+    'article.updated': ArticleUpdatedPayload;
+    'boss.damaged': BossDamagedPayload;
+    'boss.defeated': BossDefeatedPayload;
+    'boss.spawned': BossSpawnedPayload;
+    'community_post.commented': CommunityPostCommentedPayload;
+    'community_post.created': CommunityPostCreatedPayload;
+    'community_post.deleted': CommunityPostDeletedPayload;
+    'community_post.status_changed': CommunityPostStatusChangedPayload;
+    'community_post.updated': CommunityPostUpdatedPayload;
+    'community_post.voted': CommunityPostVotedPayload;
+    'customer.created': CustomerCreatedPayload;
+    'customer.deleted': CustomerDeletedPayload;
+    'customer.updated': CustomerUpdatedPayload;
+    'customer_group.created': CustomerGroupCreatedPayload;
+    'customer_group.deleted': CustomerGroupDeletedPayload;
+    'customer_group.updated': CustomerGroupUpdatedPayload;
+    'player.achievement_unlocked': PlayerAchievementUnlockedPayload;
+    'player.level_up': PlayerLevelUpPayload;
+    'player.quest_completed': PlayerQuestCompletedPayload;
+    'player.streak_milestone': PlayerStreakMilestonePayload;
+    'player.xp_gained': PlayerXpGainedPayload;
+    'social.high_five_sent': SocialHighFiveSentPayload;
+    'social.one_up_sent': SocialOneUpSentPayload;
+    'survey.submitted': SurveySubmittedPayload;
+    'ticket.assigned': TicketAssignedPayload;
+    'ticket.closed': TicketClosedPayload;
+    'ticket.created': TicketCreatedPayload;
+    'ticket.deleted': TicketDeletedPayload;
+    'ticket.message_added': TicketMessageAddedPayload;
+    'ticket.updated': TicketUpdatedPayload;
+}
+/** A webhook event delivered to your endpoint. */
+interface WebhookEvent<T extends WebhookEventType = WebhookEventType> {
+    /** Unique event ID (idempotency key). */
+    id: string;
+    /** Event type. */
+    type: T;
+    /** When the event was created (ISO 8601). */
+    created_at: string;
+    /** Team that owns this event. */
+    team_id: string;
+    /** Event-specific payload. */
+    data: WebhookEventDataMap[T];
+}
+
+type WebhookEventData<T extends WebhookEventType> = WebhookEventDataMap[T];
+
+/** A cStar webhook endpoint. */
+interface Webhook {
+    id: string;
+    object: 'webhook';
+    name: string;
+    url: string;
+    events: WebhookEventType[];
+    isActive: boolean;
+    isRestHooks: boolean;
+    includeFullObjects: boolean;
+    flatPayload: boolean;
+    lastTriggeredAt: string | null;
+    lastSuccessAt: string | null;
+    lastFailureAt: string | null;
+    consecutiveFailures: number;
+    autoDisabledAt: string | null;
+    autoDisableReason: string | null;
+    metadata: Metadata;
+    createdAt: string;
+    updatedAt: string;
+    /** Only returned on creation (POST). */
+    secret?: string;
+}
+/** Parameters for listing webhooks. */
+interface WebhookListParams extends PaginationParams {
+    active?: boolean;
+}
+/** Parameters for creating a webhook. */
+interface WebhookCreateParams {
+    name: string;
+    url: string;
+    events: WebhookEventType[];
+    isRestHooks?: boolean;
+    includeFullObjects?: boolean;
+    flatPayload?: boolean;
+    metadata?: Metadata;
+}
+/** Parameters for updating a webhook. */
+interface WebhookUpdateParams {
+    name?: string;
+    url?: string;
+    events?: WebhookEventType[];
+    isActive?: boolean;
+    includeFullObjects?: boolean;
+    flatPayload?: boolean;
+    metadata?: Record<string, string | null>;
+}
+/** Result of testing a webhook delivery. */
+interface WebhookTestResult {
+    deliveryId: string;
+    event: string;
+    url: string;
+    success: boolean;
+    status: number | null;
+    responseTimeMs: number;
+    error: string | null;
+}
+/** Parameters for subscribing (REST Hooks / Zapier protocol). */
+interface WebhookSubscribeParams {
+    targetUrl: string;
+    event: string;
+}
+/** A REST Hooks subscription. */
+interface WebhookSubscription {
+    id: string;
+    object: 'webhook';
+    [key: string]: unknown;
+}
+/** Parameters for registering a CLI listener. */
+interface WebhookListenerParams {
+    forwardUrl: string;
+    events?: string[];
+}
+/** A registered CLI listener. */
+interface WebhookListener {
+    listenerId: string;
+    secret: string;
+}
+/** Parameters for triggering a test webhook event. */
+interface WebhookTriggerTestParams {
+    event: string;
+    data?: Record<string, unknown>;
+}
+/** Result of triggering a test webhook event. */
+interface WebhookTriggerTestResult {
+    event: string;
+    deliveredTo: number;
+    [key: string]: unknown;
+}
+
+/** Manage webhook endpoints. */
+declare class WebhooksResource extends BaseResource<Webhook, WebhookListParams, WebhookCreateParams, WebhookUpdateParams> {
+    constructor(client: HttpClient);
+    /** Send a test delivery to a webhook endpoint. */
+    test(webhookId: string, params?: {
+        event?: WebhookEventType;
+    }): Promise<ApiResponse<WebhookTestResult>>;
+    /** Fire a test webhook event to all active webhooks and CLI listeners. */
+    triggerTest(params: WebhookTriggerTestParams, options?: RequestOptions): Promise<ApiResponse<WebhookTriggerTestResult>>;
+    /** Get a sample webhook payload for an event type (used by Zapier). */
+    sample(event: string): Promise<ApiResponse<unknown[]>>;
+    /** Subscribe to an event (REST Hooks / Zapier protocol). */
+    restSubscribe(params: WebhookSubscribeParams, options?: RequestOptions): Promise<ApiResponse<WebhookSubscription>>;
+    /** Unsubscribe from an event (REST Hooks / Zapier protocol). Returns void (204 No Content). */
+    unsubscribe(subscriptionId: string): Promise<void>;
+    /** Register a CLI listener (returns listenerId and signing secret). */
+    listen(params: WebhookListenerParams, options?: RequestOptions): Promise<ApiResponse<WebhookListener>>;
+    /** Deregister a CLI listener. */
+    unlisten(listenerId: string): Promise<ApiResponse<{
+        deleted: true;
+        listenerId: string;
+    }>>;
+}
+
+/** A condition in an automation rule. */
+interface AutomationCondition {
+    field: string;
+    operator: string;
+    value?: unknown;
+}
+/** Condition groups (all must match AND at least one any must match). */
+interface AutomationConditions {
+    all: AutomationCondition[];
+    any: AutomationCondition[];
+}
+/** An action in an automation rule. */
+interface AutomationAction {
+    type: string;
+    [key: string]: unknown;
+}
+/** A cStar automation rule. */
+interface AutomationRule {
+    id: string;
+    object: 'automation_rule';
+    name: string;
+    description: string;
+    triggerEvent: string;
+    triggerFilter: Record<string, unknown>;
+    conditions: AutomationConditions;
+    actions: AutomationAction[];
+    enabled: boolean;
+    position: number;
+    stopAfter: boolean;
+    maxExecutionsPerTicket: number;
+    cooldownSeconds: number;
+    executionCount: number;
+    lastExecutedAt: string | null;
+    createdBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** An automation execution log entry. */
+interface AutomationExecution {
+    id: string;
+    object: 'automation_execution';
+    ruleId: string;
+    ruleName: string | null;
+    triggerEvent: string;
+    resourceType: string;
+    resourceId: string;
+    conditionsMatched: boolean;
+    actionsExecuted: Array<{
+        action: string;
+        success: boolean;
+        error?: string;
+    }>;
+    skippedReason: string | null;
+    dryRun: boolean;
+    executionMs: number;
+    createdAt: string;
+}
+/** Parameters for listing automation rules. */
+interface AutomationListParams extends PaginationParams {
+    enabled?: boolean;
+    triggerEvent?: string;
+}
+/** Parameters for creating an automation rule. */
+interface AutomationCreateParams {
+    name: string;
+    description?: string;
+    triggerEvent: string;
+    triggerFilter?: Record<string, unknown>;
+    conditions?: AutomationConditions;
+    actions?: AutomationAction[];
+    enabled?: boolean;
+    stopAfter?: boolean;
+    maxExecutionsPerTicket?: number;
+    cooldownSeconds?: number;
+}
+/** Parameters for updating an automation rule. */
+interface AutomationUpdateParams {
+    name?: string;
+    description?: string;
+    triggerEvent?: string;
+    triggerFilter?: Record<string, unknown>;
+    conditions?: AutomationConditions;
+    actions?: AutomationAction[];
+    enabled?: boolean;
+    stopAfter?: boolean;
+    maxExecutionsPerTicket?: number;
+    cooldownSeconds?: number;
+}
+/** Parameters for listing executions. */
+interface AutomationExecutionListParams extends PaginationParams {
+    triggerEvent?: string;
+    resourceId?: string;
+}
+/** Result of a dry-run test. */
+interface AutomationTestResult {
+    wouldMatch: boolean;
+    conditionResults: {
+        all: Array<{
+            field: string;
+            operator: string;
+            value: unknown;
+            actual: unknown;
+            passed: boolean;
+        }>;
+        any: Array<{
+            field: string;
+            operator: string;
+            value: unknown;
+            actual: unknown;
+            passed: boolean;
+        }>;
+    };
+    actionsWouldExecute: Array<{
+        action: string;
+        success: boolean;
+        preview?: string;
+    }>;
+}
+
+/** Manage automation rules. */
+declare class AutomationsResource extends BaseResource<AutomationRule, AutomationListParams, AutomationCreateParams, AutomationUpdateParams> {
+    constructor(client: HttpClient);
+    /** Toggle a rule's enabled state. */
+    toggle(ruleId: string, enabled?: boolean): Promise<ApiResponse<AutomationRule>>;
+    /** Reorder rules by providing an ordered array of IDs. */
+    reorder(orderedIds: string[]): Promise<ApiResponse<AutomationRule[]>>;
+    /** Dry-run a rule against a specific resource (no actions executed). */
+    test(ruleId: string, params: {
+        resourceType: string;
+        resourceId: string;
+    }): Promise<ApiResponse<AutomationTestResult>>;
+    /** Get execution history for a specific rule. */
+    executions(ruleId: string, params?: AutomationExecutionListParams): Promise<ListResponse<AutomationExecution>>;
+    /** Get all execution history for the team. */
+    allExecutions(params?: AutomationExecutionListParams): Promise<ListResponse<AutomationExecution>>;
+    /** Test conditions against sample data (without a rule). */
+    evaluate(params: {
+        conditions: {
+            all: Array<{
+                field: string;
+                operator: string;
+                value?: unknown;
+            }>;
+            any: Array<{
+                field: string;
+                operator: string;
+                value?: unknown;
+            }>;
+        };
+        data: Record<string, unknown>;
+        changes?: Record<string, unknown>;
+    }): Promise<ApiResponse<{
+        matched: boolean;
+        conditionResults: unknown;
+    }>>;
+}
+
+/** A cStar article category. */
+interface Category {
+    id: string;
+    object: 'category';
+    name: string;
+    slug: string;
+    description: string | null;
+    icon: string | null;
+    color: string | null;
+    sortOrder: number;
+    isPublic: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for listing categories. */
+interface CategoryListParams extends PaginationParams {
+    isPublic?: boolean;
+}
+/** Parameters for creating a category. */
+interface CategoryCreateParams {
+    name: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    sortOrder?: number;
+    isPublic?: boolean;
+}
+/** Parameters for updating a category. */
+interface CategoryUpdateParams {
+    name?: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    sortOrder?: number;
+    isPublic?: boolean;
+}
+
+/** Manage article categories. */
+declare class CategoriesResource extends BaseResource<Category, CategoryListParams, CategoryCreateParams, CategoryUpdateParams> {
+    constructor(client: HttpClient);
+}
+
+/** Attachment metadata for community posts and comments. */
+interface CommunityAttachment {
+    filename: string;
+    content_type: string;
+    size_bytes: number;
+    storage_path: string;
+}
+/** Custom field definition resolved for a topic. */
+interface TopicCustomField {
+    id: string;
+    label: string;
+    type: 'text' | 'number' | 'date' | 'select' | 'checkbox' | 'url';
+    required: boolean;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultValue?: string;
+}
+/** A community discussion topic (category/board). */
+interface CommunityTopic {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    icon: string;
+    visibility: 'public' | 'members_only';
+    sortOrder: number;
+    customFields: TopicCustomField[];
+    postCount: number;
+    createdAt: string;
+}
+/** Parameters for creating a community topic via the admin SDK. */
+interface CommunityTopicCreateParams {
+    name: string;
+    slug?: string;
+    description?: string;
+    icon?: string;
+    sortOrder?: number;
+    visibility?: 'public' | 'members_only';
+    requireApproval?: boolean;
+    postGuide?: string;
+}
+/** Parameters for updating a community topic. All fields optional. */
+type CommunityTopicUpdateParams = Partial<CommunityTopicCreateParams>;
+/** A community discussion post. */
+interface CommunityPost {
+    id: string;
+    topicId: string;
+    topicName: string;
+    title: string;
+    slug: string;
+    body: string | null;
+    status: 'open' | 'answered' | 'officially_answered' | 'planned' | 'not_planned' | 'completed' | 'under_review';
+    visibility: 'public' | 'members_only';
+    voteCount: number;
+    commentCount: number;
+    isPinned: boolean;
+    isFeatured: boolean;
+    isLocked: boolean;
+    commentsEnabled: boolean;
+    customFields: Record<string, string>;
+    attachments: CommunityAttachment[];
+    authorName: string;
+    lastActivityAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** A comment on a community post. */
+interface CommunityComment {
+    id: string;
+    postId: string;
+    body: string;
+    isOfficial: boolean;
+    voteScore: number;
+    attachments: CommunityAttachment[];
+    authorName: string;
+    parentCommentId: string | null;
+    createdAt: string;
+}
+/** Query parameters for listing community posts. */
+interface CommunityPostListParams {
+    topicId?: string;
+    status?: string;
+    sort?: 'recent' | 'votes' | 'comments';
+    page?: number;
+    pageSize?: number;
+}
+/** Parameters for creating a community post. */
+interface CommunityPostCreateParams {
+    title: string;
+    body?: string;
+    topicId: string;
+    visibility?: 'public' | 'members_only';
+    customFields?: Record<string, string>;
+    attachments?: CommunityAttachment[];
+}
+/** Parameters for updating a community post. */
+interface CommunityPostUpdateParams {
+    title?: string;
+    body?: string;
+    topicId?: string;
+    status?: string;
+    visibility?: string;
+    isPinned?: boolean;
+    isLocked?: boolean;
+    isHidden?: boolean;
+    commentsEnabled?: boolean;
+    customFields?: Record<string, string>;
+    attachments?: CommunityAttachment[];
+}
+/** Parameters for creating a comment on a community post. */
+interface CommunityCommentCreateParams {
+    body: string;
+    parentCommentId?: string;
+    isOfficial?: boolean;
+    attachments?: CommunityAttachment[];
+}
+
+/** Manage community discussion posts. */
+declare class CommunityPostsResource extends BaseResource<CommunityPost, CommunityPostListParams, CommunityPostCreateParams, CommunityPostUpdateParams> {
+    constructor(client: HttpClient);
+    /** Toggle vote on a post. Returns new vote state and count. */
+    vote(postId: string): Promise<ApiResponse<{
+        voted: boolean;
+        voteCount: number;
+    }>>;
+    /** Toggle follow on a post. Returns new follow state. */
+    follow(postId: string): Promise<ApiResponse<{
+        following: boolean;
+    }>>;
+    /** List all comments on a post. */
+    listComments(postId: string): Promise<ApiResponse<CommunityComment[]>>;
+    /** Add a comment to a post. */
+    createComment(postId: string, params: CommunityCommentCreateParams): Promise<ApiResponse<CommunityComment>>;
+}
+
+/**
+ * Manage community discussion topics.
+ *
+ * As of 0.13.0 the resource exposes the full CRUD admin surface (closes
+ * F-035): `create`, `update`, `delete` were previously dashboard-only.
+ *
+ * ```ts
+ * const topic = await cstar.community.topics.create({ name: 'General' });
+ * await cstar.community.topics.update(topic.id, { description: '...' });
+ * await cstar.community.topics.del(topic.id);
+ * ```
+ */
+declare class CommunityTopicsResource extends BaseResource<CommunityTopic, Record<string, never>, CommunityTopicCreateParams, CommunityTopicUpdateParams> {
+    constructor(client: HttpClient);
+}
+
+/** A team member (agent). */
+interface Member {
+    id: string;
+    object: 'member';
+    userId: string;
+    name: string;
+    email: string;
+    avatarUrl: string | null;
+    role: string;
+    roleDisplayName: string;
+    permissions: string[];
+    level: number;
+    xp: number;
+    joinedAt: string;
+}
+/** Parameters for listing members. */
+interface MemberListParams extends PaginationParams {
+    role?: string;
+}
+/** Parameters for updating a member. */
+interface MemberUpdateParams {
+    role?: string;
+}
+/** A team invite. */
+interface Invite {
+    id: string;
+    object: 'invite';
+    email: string;
+    role: string;
+    status: string;
+    inviterName: string | null;
+    inviterEmail: string | null;
+    createdAt: string;
+    expiresAt: string;
+}
+/** Parameters for listing invites. */
+interface InviteListParams extends PaginationParams {
+    status?: string;
+}
+/** Parameters for creating an invite. */
+interface InviteCreateParams {
+    email: string;
+    role?: string;
+}
+
+/** Manage team invites as a sub-resource. */
+declare class InvitesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List pending invites. */
+    list(params?: InviteListParams): Promise<ListResponse<Invite>>;
+    /** Create and send a new invite. */
+    create(params: InviteCreateParams, options?: RequestOptions): Promise<ApiResponse<Invite>>;
+    /** Revoke a pending invite. */
+    del(inviteId: string): Promise<ApiResponse<DeleteResponse>>;
+}
+/** Manage team members. */
+declare class MembersResource {
+    private readonly client;
+    /** Sub-resource for team invites. */
+    readonly invites: InvitesResource;
+    constructor(client: HttpClient);
+    /** List all team members. */
+    list(params?: MemberListParams): Promise<ListResponse<Member>>;
+    /** Get a single member by membership ID. */
+    get(memberId: string): Promise<ApiResponse<Member>>;
+    /** Update a member's role. */
+    update(memberId: string, params: MemberUpdateParams): Promise<ApiResponse<Member>>;
+    /** Remove a member from the team. */
+    del(memberId: string): Promise<ApiResponse<DeleteResponse>>;
+}
+
+/** Team settings object. */
+interface TeamSettings {
+    object: 'settings';
+    teamName: string;
+    teamSlug: string;
+    [key: string]: unknown;
+}
+/** Parameters for updating team settings. */
+interface TeamSettingsUpdateParams {
+    [key: string]: unknown;
+}
+/** A ticket status configuration. */
+interface TicketStatus {
+    key: string;
+    object: 'status';
+    label: string;
+    color: string;
+    position: number;
+    isDefault: boolean;
+    isProtected: boolean;
+}
+/** Parameters for creating a status. */
+interface StatusCreateParams {
+    key: string;
+    label: string;
+    color?: string;
+}
+/** Parameters for updating a status. */
+interface StatusUpdateParams {
+    label?: string;
+    color?: string;
+}
+/** A quick reply template. */
+interface QuickReply {
+    id: string;
+    object: 'quick_reply';
+    title: string;
+    body: string;
+    category: string | null;
+    position: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for creating a quick reply. */
+interface QuickReplyCreateParams {
+    title: string;
+    body: string;
+    category?: string;
+}
+/** Parameters for updating a quick reply. */
+interface QuickReplyUpdateParams {
+    title?: string;
+    body?: string;
+    category?: string;
+}
+/** Business hours configuration. */
+interface BusinessHours {
+    object: 'business_hours';
+    enabled: boolean;
+    timezone: string;
+    schedule: Record<string, {
+        enabled: boolean;
+        start: string;
+        end: string;
+    }>;
+}
+/** Parameters for updating business hours. */
+interface BusinessHoursUpdateParams {
+    enabled?: boolean;
+    timezone?: string;
+    schedule?: Record<string, {
+        enabled: boolean;
+        start: string;
+        end: string;
+    }>;
+}
+/** Widget configuration. */
+interface WidgetSettings {
+    object: 'widget_settings';
+    [key: string]: unknown;
+}
+/** Parameters for updating widget settings. */
+interface WidgetSettingsUpdateParams {
+    [key: string]: unknown;
+}
+
+/** Manage ticket status configurations. */
+declare class StatusesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List all statuses. */
+    list(): Promise<ApiResponse<TicketStatus[]>>;
+    /** Create a new status. */
+    create(params: StatusCreateParams, options?: RequestOptions): Promise<ApiResponse<TicketStatus>>;
+    /** Update a status. */
+    update(statusKey: string, params: StatusUpdateParams): Promise<ApiResponse<TicketStatus>>;
+    /** Delete a status. */
+    del(statusKey: string): Promise<ApiResponse<DeleteResponse>>;
+    /** Reorder statuses. */
+    reorder(orderedKeys: string[]): Promise<ApiResponse<TicketStatus[]>>;
+}
+/** Manage quick reply templates. */
+declare class QuickRepliesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List all quick replies. */
+    list(): Promise<ApiResponse<QuickReply[]>>;
+    /** Create a new quick reply. */
+    create(params: QuickReplyCreateParams, options?: RequestOptions): Promise<ApiResponse<QuickReply>>;
+    /** Update a quick reply. */
+    update(replyId: string, params: QuickReplyUpdateParams): Promise<ApiResponse<QuickReply>>;
+    /** Delete a quick reply. */
+    del(replyId: string): Promise<ApiResponse<DeleteResponse>>;
+    /** Reorder quick replies. */
+    reorder(orderedIds: string[]): Promise<ApiResponse<QuickReply[]>>;
+}
+/** Manage team settings. */
+declare class SettingsResource {
+    private readonly client;
+    /** Ticket status configuration. */
+    readonly statuses: StatusesResource;
+    /** Quick reply templates. */
+    readonly quickReplies: QuickRepliesResource;
+    constructor(client: HttpClient);
+    /** Get all team settings. */
+    get(): Promise<ApiResponse<TeamSettings>>;
+    /** Update team settings (bulk). */
+    update(params: TeamSettingsUpdateParams): Promise<ApiResponse<TeamSettings>>;
+    /** Get business hours configuration. */
+    getBusinessHours(): Promise<ApiResponse<BusinessHours>>;
+    /** Update business hours configuration. */
+    updateBusinessHours(params: BusinessHoursUpdateParams): Promise<ApiResponse<BusinessHours>>;
+    /** Get widget settings. */
+    getWidget(): Promise<ApiResponse<WidgetSettings>>;
+    /** Update widget settings. */
+    updateWidget(params: WidgetSettingsUpdateParams): Promise<ApiResponse<WidgetSettings>>;
+}
+
+/** A notification. */
+interface Notification {
+    id: string;
+    object: 'notification';
+    type: string;
+    title: string;
+    body: string | null;
+    resourceType: string | null;
+    resourceId: string | null;
+    actorId: string | null;
+    actorName: string | null;
+    read: boolean;
+    readAt: string | null;
+    createdAt: string;
+}
+/** Parameters for listing notifications. */
+interface NotificationListParams extends PaginationParams {
+    unreadOnly?: boolean;
+}
+/** Unread count response. */
+interface UnreadCount {
+    object: 'unread_count';
+    count: number;
+}
+
+/** Manage notifications. */
+declare class NotificationsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List notifications for a user. */
+    list(params: NotificationListParams & {
+        userId: string;
+    }): Promise<ListResponse<Notification>>;
+    /** Get unread notification count for a user. */
+    unreadCount(userId: string): Promise<ApiResponse<UnreadCount>>;
+    /** Mark a single notification as read. */
+    markRead(notificationId: string, userId: string): Promise<ApiResponse<Notification>>;
+    /** Mark all notifications as read. */
+    markAllRead(userId: string): Promise<ApiResponse<{
+        markedRead: number;
+    }>>;
+    /** Delete (dismiss) a notification. For broadcast notifications, pass userId as a query param. */
+    del(notificationId: string, params?: {
+        userId?: string;
+    }): Promise<ApiResponse<DeleteResponse>>;
+}
+
+/** A mention. */
+interface Mention {
+    id: string;
+    object: 'mention';
+    senderId: string;
+    senderName: string | null;
+    recipientId: string;
+    recipientName: string | null;
+    ticketId: string | null;
+    ticketTitle: string | null;
+    isRead: boolean;
+    createdAt: string;
+}
+/** Parameters for listing mentions. */
+interface MentionListParams extends PaginationParams {
+    isRead?: string;
+}
+/** Unread mention count. */
+interface MentionUnreadCount {
+    unreadCount: number;
+}
+
+/** Manage @mentions. */
+declare class MentionsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List mentions for a user. */
+    list(params: MentionListParams & {
+        userId: string;
+    }): Promise<ListResponse<Mention>>;
+    /** Get unread mention count for a user. */
+    unreadCount(userId: string): Promise<ApiResponse<MentionUnreadCount>>;
+    /** Mark a single mention as read. */
+    markRead(mentionId: string): Promise<ApiResponse<{
+        id: string;
+        isRead: true;
+    }>>;
+    /** Mark all mentions as read for a user. */
+    markAllRead(userId: string): Promise<ApiResponse<{
+        markedRead: number;
+    }>>;
+}
+
+/** A file attachment. */
+interface Attachment {
+    id: string;
+    object: 'attachment';
+    filename: string;
+    contentType: string;
+    size: number;
+    url: string;
+    ticketId: string | null;
+    uploadedBy: string | null;
+    createdAt: string;
+}
+/** Parameters for listing attachments. */
+interface AttachmentListParams extends PaginationParams {
+    ticketId?: string;
+}
+
+/** Manage file attachments. */
+declare class AttachmentsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List attachments. */
+    list(params?: AttachmentListParams): Promise<ListResponse<Attachment>>;
+    /** Get a single attachment. */
+    get(attachmentId: string): Promise<ApiResponse<Attachment>>;
+    /** Delete an attachment. */
+    del(attachmentId: string): Promise<ApiResponse<DeleteResponse>>;
+}
+
+/** A custom field definition. */
+interface CustomField {
+    id: string;
+    object: 'custom_field';
+    name: string;
+    key: string;
+    type: 'text' | 'number' | 'select' | 'multiselect' | 'date' | 'boolean';
+    entityType: 'tickets' | 'customers';
+    description: string | null;
+    required: boolean;
+    options: string[] | null;
+    position: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for listing custom fields. */
+interface CustomFieldListParams extends PaginationParams {
+    entityType?: 'tickets' | 'customers';
+}
+/** Parameters for creating a custom field. */
+interface CustomFieldCreateParams {
+    name: string;
+    key: string;
+    type: 'text' | 'number' | 'select' | 'multiselect' | 'date' | 'boolean';
+    entityType: 'tickets' | 'customers';
+    description?: string;
+    required?: boolean;
+    options?: string[];
+}
+/** Parameters for updating a custom field. */
+interface CustomFieldUpdateParams {
+    name?: string;
+    description?: string;
+    required?: boolean;
+    options?: string[];
+}
+
+/** Manage custom field definitions. */
+declare class CustomFieldsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List custom fields. */
+    list(params?: CustomFieldListParams): Promise<ListResponse<CustomField>>;
+    /** Get a single custom field. */
+    get(fieldId: string): Promise<ApiResponse<CustomField>>;
+    /** Create a custom field. */
+    create(params: CustomFieldCreateParams, options?: RequestOptions): Promise<ApiResponse<CustomField>>;
+    /** Update a custom field. */
+    update(fieldId: string, params: CustomFieldUpdateParams): Promise<ApiResponse<CustomField>>;
+    /** Delete a custom field. */
+    del(fieldId: string): Promise<ApiResponse<DeleteResponse>>;
+    /** Reorder custom fields within a content type. */
+    reorder(contentType: 'ticket' | 'customer' | 'article', orderedIds: string[]): Promise<ApiResponse<CustomField[]>>;
+}
+
+/** An SLA rule. */
+interface SlaRule {
+    id: string;
+    object: 'sla_rule';
+    name: string;
+    description: string | null;
+    priority: string;
+    responseTarget: number;
+    resolutionTarget: number;
+    businessHoursOnly: boolean;
+    enabled: boolean;
+    position: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for listing SLA rules. */
+interface SlaRuleListParams extends PaginationParams {
+    enabled?: boolean;
+}
+/** Parameters for creating an SLA rule. */
+interface SlaRuleCreateParams {
+    name: string;
+    description?: string;
+    priority: string;
+    responseTarget: number;
+    resolutionTarget: number;
+    businessHoursOnly?: boolean;
+    enabled?: boolean;
+}
+/** Parameters for updating an SLA rule. */
+interface SlaRuleUpdateParams {
+    name?: string;
+    description?: string;
+    priority?: string;
+    responseTarget?: number;
+    resolutionTarget?: number;
+    businessHoursOnly?: boolean;
+    enabled?: boolean;
+}
+/** Parameters for SLA metrics query. */
+interface SlaMetricsParams {
+    period?: 'day' | 'week' | 'month' | 'quarter';
+    startDate?: string;
+    endDate?: string;
+    agentId?: string;
+}
+/** SLA compliance metrics response. */
+interface SlaMetrics {
+    object: 'sla_metrics';
+    period: string;
+    [key: string]: unknown;
+}
+
+/** Manage SLA rules and metrics. */
+declare class SlaResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List SLA rules. */
+    list(params?: SlaRuleListParams): Promise<ListResponse<SlaRule>>;
+    /** Create an SLA rule. */
+    create(params: SlaRuleCreateParams, options?: RequestOptions): Promise<ApiResponse<SlaRule>>;
+    /** Update an SLA rule. */
+    update(ruleId: string, params: SlaRuleUpdateParams): Promise<ApiResponse<SlaRule>>;
+    /** Delete an SLA rule. */
+    del(ruleId: string): Promise<ApiResponse<DeleteResponse>>;
+    /** Reorder SLA rules by providing an ordered array of IDs. */
+    reorder(orderedIds: string[]): Promise<ApiResponse<SlaRule[]>>;
+    /** Get SLA compliance metrics. */
+    metrics(params?: SlaMetricsParams): Promise<ApiResponse<SlaMetrics>>;
+}
+
+/**
+ * Analytics response. Shape varies by `type` parameter:
+ * - overview/tickets: tickets, priorities, statusBreakdown, responseTime, resolutionTime
+ * - performance: agents array
+ * - library: totalArticles, publishedArticles, draftArticles
+ */
+interface AnalyticsOverview {
+    object: 'analytics';
+    type: string;
+    period: string;
+    /** Present for type=overview and type=tickets */
+    tickets?: {
+        total: number;
+        new: number;
+        closed: number;
+        open: number;
+    };
+    priorities?: Record<string, number>;
+    statusBreakdown?: Record<string, number>;
+    responseTime?: {
+        avgSeconds: number | null;
+        samplesCount: number;
+    };
+    resolutionTime?: {
+        avgSeconds: number | null;
+        samplesCount: number;
+    };
+    /** Present for type=performance */
+    agents?: Array<{
+        agentId: string;
+        ticketsClosed: number;
+        avgResponseSeconds: number | null;
+        goldTier: number;
+        missedSla: number;
+    }>;
+    /** Present for type=library */
+    totalArticles?: number;
+    publishedArticles?: number;
+    draftArticles?: number;
+    [key: string]: unknown;
+}
+/** Analytics query parameters. */
+interface AnalyticsParams {
+    type?: 'overview' | 'tickets' | 'performance' | 'library';
+    period?: 'day' | 'week' | 'month' | 'quarter';
+    agentId?: string;
+}
+/** CSAT statistics (from /csat/stats). */
+interface CsatStats {
+    object: 'csat_stats';
+    period: string;
+    totalSent: number;
+    totalCompleted: number;
+    responseRate: number;
+    averageRating: number | null;
+    distribution: Record<string, number>;
+    positiveRate: number;
+}
+/** A CSAT survey (from /csat/surveys). */
+interface CsatSurvey {
+    id: string;
+    object: 'csat_survey';
+    ticketId: string;
+    customerId: string | null;
+    agentId: string | null;
+    rating: number | null;
+    comment: string | null;
+    sentAt: string | null;
+    completedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+}
+/** Parameters for listing CSAT surveys. */
+interface CsatSurveyListParams extends PaginationParams {
+    completed?: string;
+    agentId?: string;
+}
+/** Parameters for creating a CSAT survey. */
+interface CsatSurveyCreateParams {
+    ticketId: string;
+    customerId?: string;
+    agentId?: string;
+}
+/** CSAT settings. */
+interface CsatSettings {
+    object: 'csat_settings';
+    enabled: boolean;
+    delayMinutes: number;
+    expirationDays: number;
+}
+/** Parameters for updating CSAT settings. */
+interface CsatSettingsUpdateParams {
+    enabled?: boolean;
+    delayMinutes?: number;
+    expirationDays?: number;
+}
+
+/** Manage CSAT surveys. */
+declare class CsatSurveysResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List CSAT surveys. */
+    list(params?: CsatSurveyListParams): Promise<ListResponse<CsatSurvey>>;
+    /** Get a single CSAT survey. */
+    get(surveyId: string): Promise<ApiResponse<CsatSurvey>>;
+    /** Create and send a CSAT survey. */
+    create(params: CsatSurveyCreateParams): Promise<ApiResponse<CsatSurvey>>;
+}
+/** Access analytics and CSAT data. */
+declare class AnalyticsResource {
+    private readonly client;
+    /** CSAT surveys sub-resource. */
+    readonly csatSurveys: CsatSurveysResource;
+    constructor(client: HttpClient);
+    /** Get analytics data. Specify type to control the response shape. */
+    get(params?: AnalyticsParams): Promise<ApiResponse<AnalyticsOverview>>;
+    /** Get analytics overview (shortcut for type=overview). */
+    overview(params?: Omit<AnalyticsParams, 'type'>): Promise<ApiResponse<AnalyticsOverview>>;
+    /** Get agent performance stats (shortcut for type=performance). */
+    performance(params?: Omit<AnalyticsParams, 'type'> & {
+        agentId?: string;
+    }): Promise<ApiResponse<AnalyticsOverview>>;
+    /** Get library analytics (shortcut for type=library). */
+    library(params?: Omit<AnalyticsParams, 'type'>): Promise<ApiResponse<AnalyticsOverview>>;
+    /** Get CSAT statistics. */
+    csatStats(params?: {
+        period?: string;
+        agentId?: string;
+    }): Promise<ApiResponse<CsatStats>>;
+    /** Get CSAT settings. */
+    csatSettings(): Promise<ApiResponse<CsatSettings>>;
+    /** Update CSAT settings. */
+    updateCsatSettings(params: CsatSettingsUpdateParams): Promise<ApiResponse<CsatSettings>>;
+}
+
+/** Bulk operation result. */
+interface BulkResult {
+    object: 'bulk_result';
+    action: string;
+    resource: string;
+    total: number;
+    succeeded: number;
+    failed: number;
+    errors: Array<{
+        id: string;
+        error: string;
+    }>;
+}
+/** Parameters for a bulk update. */
+interface BulkUpdateParams {
+    resource: 'tickets' | 'customers' | 'articles';
+    ids: string[];
+    data: Record<string, unknown>;
+}
+/** Parameters for a bulk delete. */
+interface BulkDeleteParams {
+    resource: 'tickets' | 'customers' | 'articles';
+    ids: string[];
+}
+
+/** Perform bulk operations on resources. */
+declare class BulkResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Bulk update resources. */
+    update(params: BulkUpdateParams, options?: RequestOptions): Promise<ApiResponse<BulkResult>>;
+    /** Bulk delete resources. */
+    del(params: BulkDeleteParams, options?: RequestOptions): Promise<ApiResponse<BulkResult>>;
+}
+
+/** Export request parameters. */
+interface ExportCreateParams {
+    resources: Array<{
+        type: 'tickets' | 'customers' | 'articles';
+        filters?: Record<string, unknown>;
+    }>;
+    format?: 'json' | 'csv';
+}
+/** Export response. */
+interface ExportResult {
+    object: 'export';
+    format: string;
+    resources: Record<string, unknown[]> | string;
+    totalRows: number;
+}
+
+/** Import request parameters. */
+interface ImportCreateParams {
+    resource: 'tickets' | 'customers' | 'articles';
+    records: Record<string, unknown>[];
+    mergeStrategy?: 'skip' | 'overwrite' | 'merge';
+}
+/** Import result. */
+interface ImportResult {
+    object: 'import_result';
+    resource: string;
+    total: number;
+    created: number;
+    updated: number;
+    skipped: number;
+    errors: Array<{
+        index: number;
+        error: string;
+    }>;
+}
+/** Import log entry. */
+interface ImportLog {
+    id: string;
+    object: 'import_log';
+    resource: string;
+    status: string;
+    totalRecords: number;
+    created: number;
+    updated: number;
+    skipped: number;
+    errors: number;
+    createdAt: string;
+}
+/** Parameters for listing import logs. */
+interface ImportLogListParams extends PaginationParams {
+    resource?: string;
+}
+
+/** Export data from your team. */
+declare class ExportResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Create an export. Returns exported data synchronously. */
+    create(params: ExportCreateParams, options?: RequestOptions): Promise<ApiResponse<ExportResult>>;
+}
+/** Import data into your team. */
+declare class ImportResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Run an import. Processes records synchronously (max 500). */
+    create(params: ImportCreateParams, options?: RequestOptions): Promise<ApiResponse<ImportResult>>;
+    /** List import history logs. */
+    logs(params?: ImportLogListParams): Promise<ListResponse<ImportLog>>;
+    /** Get a single import log. */
+    getLog(logId: string): Promise<ApiResponse<ImportLog>>;
+}
+
+/** An audit log entry. */
+interface AuditLogEntry {
+    id: string;
+    object: 'audit_log_entry';
+    action: string;
+    resourceType: string;
+    resourceId: string | null;
+    actorId: string | null;
+    actorName: string | null;
+    actorType: string;
+    details: Record<string, unknown>;
+    ipAddress: string | null;
+    createdAt: string;
+}
+/** Parameters for listing audit log entries. */
+interface AuditLogListParams extends PaginationParams {
+    action?: string;
+    resourceType?: string;
+    resourceId?: string;
+    actorId?: string;
+    startDate?: string;
+    endDate?: string;
+}
+
+/** Access the audit log. */
+declare class AuditLogResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List audit log entries. */
+    list(params?: AuditLogListParams): Promise<ListResponse<AuditLogEntry>>;
+}
+
+/** Search result item. Shape varies by type. */
+interface SearchResult {
+    type: 'ticket' | 'customer' | 'article';
+    id: string;
+    /** Title (tickets, articles) or name (customers). */
+    title?: string;
+    name?: string;
+    email?: string;
+    status?: string;
+    priority?: string;
+    [key: string]: unknown;
+}
+/** Search parameters. */
+interface SearchParams {
+    query: string;
+    types?: Array<'tickets' | 'customers' | 'articles'>;
+    limit?: number;
+}
+
+/** Search across tickets, customers, and articles. */
+declare class SearchResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Perform a cross-resource search. */
+    query(params: SearchParams): Promise<ApiResponse<SearchResult[]>>;
+}
+
+/** A tag with usage count. */
+interface Tag {
+    object: 'tag';
+    name: string;
+    count: number;
+}
+/** Parameters for listing tags. */
+interface TagListParams extends PaginationParams {
+    search?: string;
+}
+
+/** Manage tags. */
+declare class TagsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List all tags with usage counts. */
+    list(params?: TagListParams): Promise<ListResponse<Tag>>;
+    /** Create a tag. */
+    create(name: string, options?: RequestOptions): Promise<ApiResponse<Tag>>;
+    /** Delete a tag. */
+    del(name: string): Promise<ApiResponse<DeleteResponse>>;
+}
+
+/** An activity/timeline event. */
+interface ActivityEvent {
+    id: string;
+    object: 'activity';
+    type: string;
+    resourceType: string;
+    resourceId: string | null;
+    actorId: string | null;
+    actorName: string | null;
+    description: string;
+    details: Record<string, unknown>;
+    createdAt: string;
+}
+/** Parameters for listing activity. */
+interface ActivityListParams extends PaginationParams {
+    resourceType?: string;
+    resourceId?: string;
+    type?: string;
+}
+
+/** Access the activity feed. */
+declare class ActivityResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List recent activity events. */
+    list(params?: ActivityListParams): Promise<ListResponse<ActivityEvent>>;
+}
+
+/** A customer group/segment. */
+interface CustomerGroup {
+    id: string;
+    object: 'customer_group';
+    name: string;
+    description: string | null;
+    filters: Record<string, unknown>;
+    customerCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for listing customer groups. */
+interface CustomerGroupListParams extends PaginationParams {
+    search?: string;
+}
+/** Parameters for creating a customer group. */
+interface CustomerGroupCreateParams {
+    name: string;
+    description?: string;
+    filters?: Record<string, unknown>;
+}
+/** Parameters for updating a customer group. */
+interface CustomerGroupUpdateParams {
+    name?: string;
+    description?: string;
+    filters?: Record<string, unknown>;
+}
+/** Parameters for listing group members. */
+interface CustomerGroupMemberListParams extends PaginationParams {
+}
+/** Parameters for adding members to a group. */
+interface CustomerGroupAddMembersParams {
+    customerId?: string;
+    customerIds?: string[];
+}
+/** Group members list result. */
+interface CustomerGroupMembersResult {
+    data: Array<{
+        id: string;
+        object: 'customer';
+        name: string | null;
+        email: string | null;
+        sentiment: string;
+        tags: string[];
+        joinedGroupAt: string;
+    }>;
+    pagination: {
+        total: number;
+        page: number;
+        pageSize: number;
+        hasMore: boolean;
+    };
+}
+/** Result of adding members to a group. */
+interface CustomerGroupAddResult {
+    added: number;
+    total: number;
+    skipped: number;
+}
+/** Result of removing a member from a group. */
+interface CustomerGroupRemoveResult {
+    removed: true;
+    customerId: string;
+    groupId: string;
+}
+
+/** Manage group memberships as a sub-resource. */
+declare class CustomerGroupMembersResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List members in a group. */
+    list(groupId: string, params?: CustomerGroupMemberListParams): Promise<ApiResponse<CustomerGroupMembersResult>>;
+    /** Add member(s) to a group. */
+    add(groupId: string, params: CustomerGroupAddMembersParams, options?: RequestOptions): Promise<ApiResponse<CustomerGroupAddResult>>;
+    /** Remove a member from a group. */
+    remove(groupId: string, customerId: string): Promise<ApiResponse<CustomerGroupRemoveResult>>;
+}
+/** Manage customer groups/segments. */
+declare class CustomerGroupsResource extends BaseResource<CustomerGroup, CustomerGroupListParams, CustomerGroupCreateParams, CustomerGroupUpdateParams> {
+    /** Sub-resource for group memberships. */
+    readonly members: CustomerGroupMembersResource;
+    constructor(client: HttpClient);
+}
+
+/** Player stats. */
+interface Player {
+    object: 'player';
+    userId: string;
+    name: string | null;
+    level: number;
+    xp: number;
+    xpToNextLevel: number;
+    totalXp: number;
+    streak: number;
+    ticketsResolved: number;
+    rank: number | null;
+    scores: {
+        daily: number;
+        weekly: number;
+        allTime: number;
+    };
+    [key: string]: unknown;
+}
+/** Boss state. */
+interface Boss {
+    object: 'boss';
+    active: boolean;
+    name: string | null;
+    title: string | null;
+    difficulty: string | null;
+    health: number;
+    maxHealth: number;
+    healthPercent: number;
+    abilities: Record<string, unknown> | null;
+    participants: Array<{
+        userId: string;
+        name: string | null;
+        damage: number;
+    }>;
+    spawnedAt: string | null;
+}
+/** Boss damage result. */
+interface BossDamageResult {
+    object: 'boss_damage';
+    damage: number;
+    bossHealth: number;
+    bossMaxHealth: number;
+    defeated: boolean;
+    [key: string]: unknown;
+}
+/** Boss defeat record. */
+interface BossDefeat {
+    id: string;
+    object: 'boss_defeat';
+    bossName: string;
+    difficulty: string;
+    defeatedAt: string;
+    participants: Array<{
+        userId: string;
+        name: string | null;
+        damage: number;
+    }>;
+    [key: string]: unknown;
+}
+/** Parameters for listing boss defeats. */
+interface BossDefeatListParams extends PaginationParams {
+}
+/** Parameters for spawning a boss. */
+interface BossSpawnParams {
+    difficulty?: 'easy' | 'medium' | 'hard';
+}
+/** Parameters for dealing boss damage. */
+interface BossDamageParams {
+    userId: string;
+    ticketId: string;
+}
+/** Leaderboard entry. */
+interface LeaderboardEntry {
+    object: 'leaderboard_entry';
+    rank: number;
+    userId: string;
+    name: string | null;
+    avatarUrl: string | null;
+    score: number;
+    level: number;
+}
+/** Leaderboard parameters. */
+interface LeaderboardParams extends PaginationParams {
+    period?: 'daily' | 'weekly' | 'allTime';
+}
+/** An achievement. */
+interface Achievement {
+    id: string;
+    object: 'achievement';
+    name: string;
+    description: string | null;
+    category: string | null;
+    icon: string | null;
+    xpReward: number;
+    unlocked: boolean;
+    unlockedAt: string | null;
+    progress?: {
+        current: number;
+        target: number;
+    };
+}
+/** Parameters for listing achievements. */
+interface AchievementListParams extends PaginationParams {
+    category?: string;
+}
+/** A daily quest. */
+interface Quest {
+    id: string;
+    object: 'quest';
+    title: string;
+    description: string | null;
+    type: string;
+    target: number;
+    current: number;
+    completed: boolean;
+    xpReward: number;
+    completedAt: string | null;
+}
+/** A daily puzzle. */
+interface Puzzle {
+    id: string;
+    object: 'puzzle';
+    type: string;
+    difficulty: string;
+    data: Record<string, unknown>;
+    completed: boolean;
+    xpReward: number;
+}
+/** Puzzle completion parameters. */
+interface PuzzleCompleteParams {
+    userId: string;
+    answer: string;
+}
+/** Puzzle completion result. */
+interface PuzzleCompleteResult {
+    object: 'puzzle_result';
+    correct: boolean;
+    xpAwarded: number;
+    streak: number;
+}
+/** Puzzle streak info. */
+interface PuzzleStreak {
+    object: 'puzzle_streak';
+    userId: string;
+    currentStreak: number;
+    longestStreak: number;
+    totalCompleted: number;
+}
+/** A one-up (kudos to a teammate). */
+interface OneUp {
+    id: string;
+    object: 'one_up';
+    senderId: string;
+    senderName: string | null;
+    recipientId: string;
+    recipientName: string | null;
+    message: string | null;
+    createdAt: string;
+}
+/** Parameters for listing one-ups. */
+interface OneUpListParams extends PaginationParams {
+    userId?: string;
+}
+/** Parameters for sending a one-up. */
+interface OneUpCreateParams {
+    recipientId: string;
+    message?: string;
+    userId: string;
+}
+/** Remaining one-ups info. */
+interface OneUpRemaining {
+    object: 'one_up_remaining';
+    remaining: number;
+    limit: number;
+    resetsAt: string;
+}
+/** A high five (kudos between teams). */
+interface HighFive {
+    id: string;
+    object: 'high_five';
+    senderTeamId: string;
+    senderTeamName: string | null;
+    recipientTeamId: string;
+    recipientTeamName: string | null;
+    senderId: string;
+    senderName: string | null;
+    message: string | null;
+    createdAt: string;
+}
+/** Parameters for listing high fives. */
+interface HighFiveListParams extends PaginationParams {
+}
+/** Parameters for sending a high five. */
+interface HighFiveCreateParams {
+    recipientTeamId: string;
+    message?: string;
+    userId: string;
+}
+/** Can-send check result. */
+interface HighFiveCanSend {
+    object: 'high_five_can_send';
+    canSend: boolean;
+    reason: string | null;
+}
+/** An unlocked cosmetic. */
+interface Cosmetic {
+    id: string;
+    object: 'cosmetic';
+    type: string;
+    name: string;
+    rarity: string | null;
+    unlockedAt: string;
+}
+/** Cosmetic preferences. */
+interface CosmeticPreferences {
+    object: 'cosmetic_preferences';
+    [key: string]: unknown;
+}
+/** A game season. */
+interface Season {
+    id: string;
+    object: 'season';
+    name: string;
+    number: number;
+    startDate: string;
+    endDate: string;
+    active: boolean;
+    daysRemaining: number | null;
+}
+/** Season stats for a user. */
+interface SeasonStats {
+    object: 'season_stats';
+    seasonId: string;
+    userId: string;
+    xp: number;
+    level: number;
+    ticketsResolved: number;
+    [key: string]: unknown;
+}
+/** Skill tree data. */
+interface SkillTree {
+    object: 'skill_tree';
+    skills: Array<{
+        id: string;
+        name: string;
+        description: string;
+        category: string;
+        maxLevel: number;
+        currentLevel: number;
+        bonuses: Record<string, unknown>;
+    }>;
+    availablePoints: number;
+    totalPointsSpent: number;
+}
+/** Skill allocation parameters. */
+interface SkillAllocateParams {
+    skillId: string;
+    userId: string;
+}
+/** Skill allocation result. */
+interface SkillAllocateResult {
+    object: 'skill_allocate';
+    skillId: string;
+    newLevel: number;
+    remainingPoints: number;
+}
+/** Game balance configuration (read-only constants from /game/config). */
+interface GameConfig {
+    object: 'game_config';
+    rewards: Record<string, unknown>;
+    streaks: Record<string, unknown>;
+    combo: Record<string, unknown>;
+    boss: Record<string, unknown>;
+    scoring: Record<string, unknown>;
+    leveling: Record<string, unknown>;
+    social: Record<string, unknown>;
+}
+
+declare class BossResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Get current boss state. */
+    current(): Promise<ApiResponse<Boss>>;
+    /** Check if a boss is active (lightweight). */
+    isActive(): Promise<ApiResponse<{
+        active: boolean;
+    }>>;
+    /** Spawn a new boss. */
+    spawn(params?: BossSpawnParams, options?: RequestOptions): Promise<ApiResponse<Boss>>;
+    /** Deal damage to the current boss. */
+    damage(params: BossDamageParams, options?: RequestOptions): Promise<ApiResponse<BossDamageResult>>;
+    /** List boss defeat history. */
+    defeats(params?: BossDefeatListParams): Promise<ListResponse<BossDefeat>>;
+    /** Get a single defeat record. */
+    getDefeat(defeatId: string): Promise<ApiResponse<BossDefeat>>;
+}
+declare class AchievementsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List all achievements with progress. */
+    list(params?: AchievementListParams): Promise<ApiResponse<{
+        object: 'achievement_list';
+        data: Achievement[];
+        summary: {
+            total: number;
+            unlocked: number;
+            totalXpEarned: number;
+            totalGoldEarned: number;
+            byCategory: Record<string, {
+                total: number;
+                unlocked: number;
+            }>;
+            byRarity: Record<string, {
+                total: number;
+                unlocked: number;
+            }>;
+        };
+    }>>;
+    /** List unlocked achievements only. */
+    unlocked(params?: {
+        userId: string;
+    }): Promise<ApiResponse<Achievement[]>>;
+    /** Get a single achievement. */
+    get(achievementId: string, params?: {
+        userId?: string;
+    }): Promise<ApiResponse<Achievement>>;
+    /** Get recently unlocked achievements across the team. */
+    recent(params?: {
+        limit?: number;
+    }): Promise<ApiResponse<{
+        object: 'list';
+        data: Achievement[];
+    }>>;
+}
+declare class GameActivityResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Get the team activity feed. */
+    list(params?: {
+        limit?: number;
+        before?: string;
+    }): Promise<ApiResponse<{
+        object: 'list';
+        data: unknown[];
+        cursor: string | null;
+    }>>;
+    /** Get activity for a specific member. */
+    forMember(memberId: string, params?: {
+        limit?: number;
+    }): Promise<ApiResponse<{
+        object: 'list';
+        data: unknown[];
+    }>>;
+}
+declare class QuestsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Get today's quests. */
+    today(params?: {
+        userId?: string;
+    }): Promise<ApiResponse<Quest[]>>;
+    /** Get quest history. */
+    history(params?: {
+        userId?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<ApiResponse<unknown>>;
+}
+declare class PuzzlesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Get today's puzzle. */
+    today(params?: {
+        userId?: string;
+    }): Promise<ApiResponse<Puzzle>>;
+    /** Submit a puzzle answer. */
+    complete(params: PuzzleCompleteParams, options?: RequestOptions): Promise<ApiResponse<PuzzleCompleteResult>>;
+    /** Get puzzle streak for a user. */
+    streak(params: {
+        userId: string;
+    }): Promise<ApiResponse<PuzzleStreak>>;
+    /** Get puzzle leaderboard. */
+    leaderboard(params?: {
+        type?: 'scores' | 'streaks';
+        limit?: number;
+    }): Promise<ApiResponse<unknown>>;
+}
+declare class OneUpsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List one-ups. */
+    list(params?: OneUpListParams): Promise<ListResponse<OneUp>>;
+    /** Send a one-up. */
+    send(params: OneUpCreateParams, options?: RequestOptions): Promise<ApiResponse<OneUp>>;
+    /** Check remaining free one-ups today. */
+    remaining(params: {
+        userId: string;
+    }): Promise<ApiResponse<OneUpRemaining>>;
+}
+declare class HighFivesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List high fives. */
+    list(params?: HighFiveListParams): Promise<ListResponse<HighFive>>;
+    /** Send a high five. */
+    send(params: HighFiveCreateParams, options?: RequestOptions): Promise<ApiResponse<HighFive>>;
+    /** Check if you can send a high five to a team. */
+    canSend(recipientTeamId: string, params: {
+        userId: string;
+    }): Promise<ApiResponse<HighFiveCanSend>>;
+}
+declare class CosmeticsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List unlocked cosmetics. */
+    list(params?: {
+        userId?: string;
+    }): Promise<ApiResponse<Cosmetic[]>>;
+    /** Get cosmetic preferences. */
+    getPreferences(params: {
+        userId: string;
+    }): Promise<ApiResponse<CosmeticPreferences>>;
+    /** Update cosmetic preferences. */
+    updatePreferences(params: Record<string, unknown>): Promise<ApiResponse<CosmeticPreferences>>;
+}
+declare class SeasonsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** List all seasons. */
+    list(): Promise<ApiResponse<Season[]>>;
+    /** Get the current active season. */
+    current(): Promise<ApiResponse<Season>>;
+    /** Get user stats for a season. */
+    stats(seasonId: string, params: {
+        userId: string;
+    }): Promise<ApiResponse<SeasonStats>>;
+}
+declare class SkillsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Get the skill tree with current allocations. */
+    get(params: {
+        userId: string;
+    }): Promise<ApiResponse<SkillTree>>;
+    /** Allocate a skill point. */
+    allocate(params: SkillAllocateParams, options?: RequestOptions): Promise<ApiResponse<SkillAllocateResult>>;
+    /** Reset all skill allocations. */
+    reset(params: {
+        userId: string;
+    }, options?: RequestOptions): Promise<ApiResponse<SkillTree>>;
+}
+/** Access all gamification features. */
+declare class GameResource {
+    private readonly client;
+    /** Boss battles. */
+    readonly boss: BossResource;
+    /** Achievements. */
+    readonly achievements: AchievementsResource;
+    /** Daily quests. */
+    readonly quests: QuestsResource;
+    /** Daily puzzles. */
+    readonly puzzles: PuzzlesResource;
+    /** One-ups (teammate kudos). */
+    readonly oneUps: OneUpsResource;
+    /** High fives (team-to-team kudos). */
+    readonly highFives: HighFivesResource;
+    /** Cosmetics. */
+    readonly cosmetics: CosmeticsResource;
+    /** Seasons. */
+    readonly seasons: SeasonsResource;
+    /** Skill tree. */
+    readonly skills: SkillsResource;
+    /** Game activity feed. */
+    readonly activity: GameActivityResource;
+    constructor(client: HttpClient);
+    /** Get current player stats. */
+    player(params?: {
+        userId?: string;
+    }): Promise<ApiResponse<Player>>;
+    /** Get a specific player's stats by membership ID. */
+    getPlayer(memberId: string): Promise<ApiResponse<Player>>;
+    /**
+     * Get the team leaderboard. Returns the unwrapped envelope from the
+     * `/game/leaderboard` endpoint (`{entries, totalParticipants, period, ...}`)
+     * — wider than a flat array because the server includes the period and
+     * a participant count alongside the entries.
+     */
+    leaderboard(params?: LeaderboardParams): Promise<{
+        entries: LeaderboardEntry[];
+        totalParticipants?: number;
+        period?: string;
+    }>;
+    /** Get the current user's leaderboard position. */
+    myRank(params?: {
+        userId?: string;
+        period?: string;
+    }): Promise<ApiResponse<LeaderboardEntry>>;
+    /** Get game balance configuration (read-only constants). */
+    config(): Promise<ApiResponse<GameConfig>>;
+    /**
+     * Subscribe to live boss battle state.
+     * Updates on boss.spawned, boss.damaged, boss.defeated events.
+     */
+    subscribeBoss(realtime: CStarRealtime): Subscription$1<Boss>;
+    /**
+     * Subscribe to player stats (XP, gold, level, streaks).
+     * Updates on achievement.unlocked, quest.completed, level.up events.
+     */
+    subscribePlayer(realtime: CStarRealtime, userId?: string): Subscription$1<Player>;
+    /**
+     * Subscribe to the team leaderboard.
+     * Updates when scores change.
+     */
+    subscribeLeaderboard(realtime: CStarRealtime, params?: LeaderboardParams): Subscription$1<LeaderboardEntry>;
+    /**
+     * Subscribe to team activity feed (achievements, boss defeats, level ups).
+     * Rolling feed of recent game events.
+     */
+    subscribeActivity(realtime: CStarRealtime): Subscription$1<Record<string, unknown>>;
+}
+
+/** AI action types. */
+type AiAction = 'auto-tag' | 'suggest-reply' | 'summarize' | 'improve';
+/** Parameters for an AI action. */
+interface AiActionParams {
+    action: AiAction;
+    ticketId?: string;
+    text?: string;
+    context?: Record<string, unknown>;
+}
+/** AI action result. */
+interface AiActionResult {
+    object: 'ai_result';
+    action: AiAction;
+    result: unknown;
+}
+
+/** AI-powered actions (auto-tag, suggest reply, summarize, improve). */
+declare class AiResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Run an AI action. */
+    run(params: AiActionParams, options?: RequestOptions): Promise<ApiResponse<AiActionResult>>;
+    /** Auto-tag a ticket. */
+    autoTag(ticketId: string): Promise<ApiResponse<AiActionResult>>;
+    /** Suggest a reply for a ticket. */
+    suggestReply(ticketId: string): Promise<ApiResponse<AiActionResult>>;
+    /** Summarize a ticket. */
+    summarize(ticketId: string): Promise<ApiResponse<AiActionResult>>;
+    /** Improve text. */
+    improve(text: string): Promise<ApiResponse<AiActionResult>>;
+}
+
+/** A saved view / filter preset. */
+interface SavedView {
+    id: string;
+    object: 'saved_view';
+    name: string;
+    description: string | null;
+    entityType: 'tickets' | 'customers' | 'articles' | 'community_posts';
+    filters: Record<string, unknown>;
+    sortField: string;
+    sortDirection: 'asc' | 'desc';
+    visibility: 'private' | 'team';
+    createdBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Parameters for listing views. */
+interface ViewListParams extends PaginationParams {
+    entityType?: string;
+}
+/** Parameters for creating a view. */
+interface ViewCreateParams {
+    name: string;
+    description?: string;
+    entityType: 'tickets' | 'customers' | 'articles' | 'community_posts';
+    filters?: Record<string, unknown>;
+    sortField?: string;
+    sortDirection?: 'asc' | 'desc';
+    visibility?: 'private' | 'team';
+}
+/** Parameters for updating a view. */
+interface ViewUpdateParams {
+    name?: string;
+    description?: string;
+    filters?: Record<string, unknown>;
+    sortField?: string;
+    sortDirection?: 'asc' | 'desc';
+    visibility?: 'private' | 'team';
+}
+/** Parameters for executing a view. */
+interface ViewExecuteParams extends PaginationParams {
+}
+
+/** Manage saved views (saved filters). */
+declare class ViewsResource extends BaseResource<SavedView, ViewListParams, ViewCreateParams, ViewUpdateParams> {
+    constructor(client: HttpClient);
+    /** Execute a view — returns the filtered results. The server uses the view's entity_type to determine which table to query. */
+    execute(viewId: string, params?: ViewExecuteParams): Promise<ListResponse<unknown>>;
+}
+
+/** Subscription status. */
+interface Subscription {
+    object: 'subscription';
+    status: string;
+    plan: string | null;
+    currentPeriodStart: string | null;
+    currentPeriodEnd: string | null;
+    cancelAtPeriodEnd: boolean;
+    memberCount: number;
+    [key: string]: unknown;
+}
+/** Billing portal result. */
+interface BillingPortal {
+    object: 'billing_portal';
+    url: string;
+}
+/** Parameters for creating a billing portal session. */
+interface BillingPortalParams {
+    returnUrl?: string;
+}
+
+/** Access billing and subscription data. */
+declare class BillingResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /** Get current subscription status. */
+    subscription(): Promise<ApiResponse<Subscription>>;
+    /** Create a Stripe billing portal session. */
+    portal(params?: BillingPortalParams): Promise<ApiResponse<BillingPortal>>;
+}
+
+interface QueueItem {
+    /** Unique queue item ID. */
+    id: string;
+    /** HTTP method. */
+    method: string;
+    /** API path. */
+    path: string;
+    /** Request body. */
+    body: Record<string, unknown>;
+    /** When the item was queued. */
+    queuedAt: string;
+}
+interface QueueResult {
+    id: string;
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+interface OfflineQueueOptions {
+    /** Storage backend: 'memory' (default) or 'localStorage' for browser persistence. */
+    storage?: 'memory' | 'localStorage';
+}
+/**
+ * Offline mutation queue that stores failed requests and replays them when online.
+ *
+ * When `CStarClient` is used with network issues, mutations can be enqueued
+ * instead of failing. The queue persists to localStorage (in browsers) and
+ * auto-flushes when the network comes back.
+ *
+ * ```typescript
+ * const queue = new OfflineQueue(httpClient, { storage: 'localStorage' });
+ * queue.enqueue('POST', '/tickets', { title: 'Bug report' });
+ * // Later, when online:
+ * const results = await queue.flush();
+ * ```
+ */
+declare class OfflineQueue {
+    private readonly httpClient;
+    private items;
+    private autoFlushEnabled;
+    private onlineHandler;
+    private readonly useLocalStorage;
+    constructor(httpClient: HttpClient, options?: OfflineQueueOptions);
+    /** Queue a mutation for later execution. Returns a queue item ID. */
+    enqueue(method: string, path: string, body: Record<string, unknown>): string;
+    /**
+     * Process all queued mutations in order. Returns results for each item.
+     * Failed items are re-queued at the front to preserve ordering.
+     * Items enqueued during flush are appended after re-queued failures.
+     */
+    flush(): Promise<QueueResult[]>;
+    /** Get pending queue items. */
+    get pending(): QueueItem[];
+    /** Number of items in the queue. */
+    get size(): number;
+    /** Clear all pending items. */
+    clear(): void;
+    /**
+     * Enable auto-flush when the browser goes online.
+     * Only works in browser environments with the `online` event.
+     */
+    enableAutoFlush(): void;
+    /** Disable auto-flush and clean up event listeners. */
+    disableAutoFlush(): void;
+    private saveToStorage;
+    private loadFromStorage;
+}
+
+/** 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 class CStarError extends Error {
+    readonly type: string;
+    readonly code: string;
+    readonly param?: string;
+    readonly docUrl: string;
+    readonly requestId?: string;
+    readonly statusCode: number;
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+/** Thrown when authentication fails (401). */
+declare class CStarAuthenticationError extends CStarError {
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+/** Thrown when rate limited (429). Includes retry timing. */
+declare class CStarRateLimitError extends CStarError {
+    readonly retryAfter: number;
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody, retryAfter?: number);
+}
+/** Thrown when a resource is not found (404). */
+declare class CStarNotFoundError extends CStarError {
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+/** Thrown on invalid request parameters (400/422). */
+declare class CStarValidationError extends CStarError {
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+/** Thrown when authenticated but lacking permission (403). */
+declare class CStarPermissionError extends CStarError {
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+/** Thrown on resource conflicts (409). */
+declare class CStarConflictError extends CStarError {
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+/** Thrown on internal server errors (500+). */
+declare class CStarServerError extends CStarError {
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+/**
+ * Thrown when the call landed on a feature that the team has not enabled
+ * or configured (e.g. Quick Help on a team without an AI agent). Carries
+ * `feature` and `enableUrl` so the caller can route the user to the
+ * dashboard setting that fixes it.
+ *
+ * Closes F-031 — anonymous QuickHelp `.ask()` previously surfaced as an
+ * unactionable 503.
+ */
+declare class CStarFeatureDisabledError extends CStarError {
+    readonly feature: string;
+    readonly enableUrl: string;
+    constructor(messageOrStatus: string | number, body?: ApiErrorBody);
+}
+
+/** Configuration for the CStarClient. */
+interface CStarClientConfig {
+    /** Your API key (sk_live_*, sk_test_*, pk_live_*, or pk_test_*). */
+    apiKey: string;
+    /** Your team ID. */
+    teamId: string;
+    /** Override the base URL (defaults to https://www.cstar.help). */
+    baseUrl?: string;
+    /** API version header (defaults to 2026-03-01). */
+    version?: string;
+    /** Max retry attempts for failed requests (defaults to 3). */
+    maxRetries?: number;
+    /** Request timeout in ms (defaults to 30000). */
+    timeout?: number;
+    /** Enable offline queue — queues mutations when network fails, auto-flushes on reconnect. */
+    offline?: boolean | OfflineQueueOptions;
+}
+/**
+ * The cStar admin API client. **Server-side only.**
+ *
+ * Requires a secret API key (`sk_live_*` or `sk_test_*`). Never use this in
+ * client-side / browser code — your secret key would be exposed to anyone
+ * viewing your site.
+ *
+ * For client-side integrations, use:
+ * - `@cstar.help/js/chat` — Customer chat widget (publishable key)
+ * - `@cstar.help/js/library` — Public knowledge base (no auth)
+ * - `@cstar.help/js/community` — Public community forum (no auth)
+ *
+ * ```typescript
+ * import { CStarClient } from '@cstar.help/js';
+ *
+ * const cstar = new CStarClient({
+ *   apiKey: process.env.CSTAR_SECRET_KEY, // sk_live_... or sk_test_...
+ *   teamId: process.env.CSTAR_TEAM_ID,
+ * });
+ *
+ * const { data } = await cstar.tickets.list({ status: 'open' });
+ * ```
+ */
+declare class CStarClient {
+    /** Manage support tickets. */
+    readonly tickets: TicketsResource;
+    /** Manage customers. */
+    readonly customers: CustomersResource;
+    /** Manage knowledge base articles. */
+    readonly articles: ArticlesResource;
+    /** Manage webhook endpoints. */
+    readonly webhooks: WebhooksResource;
+    /** Manage automation rules. */
+    readonly automations: AutomationsResource;
+    /** Manage article categories. */
+    readonly categories: CategoriesResource;
+    /** Manage community posts and topics. */
+    readonly community: {
+        readonly posts: CommunityPostsResource;
+        readonly topics: CommunityTopicsResource;
+    };
+    /** Manage team members and invites. */
+    readonly members: MembersResource;
+    /** Manage team settings, statuses, quick replies, business hours, and widget. */
+    readonly settings: SettingsResource;
+    /** Manage notifications. */
+    readonly notifications: NotificationsResource;
+    /** Manage @mentions. */
+    readonly mentions: MentionsResource;
+    /** Manage file attachments. */
+    readonly attachments: AttachmentsResource;
+    /** Manage custom field definitions. */
+    readonly customFields: CustomFieldsResource;
+    /** Manage SLA rules. */
+    readonly sla: SlaResource;
+    /** Access analytics and CSAT data. */
+    readonly analytics: AnalyticsResource;
+    /** Perform bulk operations. */
+    readonly bulk: BulkResource;
+    /** Export data. */
+    readonly export: ExportResource;
+    /** Import data. */
+    readonly import: ImportResource;
+    /** Access the audit log. */
+    readonly auditLog: AuditLogResource;
+    /** Search across resources. */
+    readonly search: SearchResource;
+    /** Manage tags. */
+    readonly tags: TagsResource;
+    /** Access the activity feed. */
+    readonly activity: ActivityResource;
+    /** Manage customer groups/segments. */
+    readonly customerGroups: CustomerGroupsResource;
+    /** Access all gamification features. */
+    readonly game: GameResource;
+    /** AI-powered actions. */
+    readonly ai: AiResource;
+    /** Manage saved views. */
+    readonly views: ViewsResource;
+    /** Access billing and subscription data. */
+    readonly billing: BillingResource;
+    /** Real-time event stream via SSE. */
+    readonly realtime: CStarRealtime;
+    /**
+     * Offline mutation queue. Only available when `offline: true` is passed to the constructor.
+     * Queues failed mutations and replays them when the network returns.
+     */
+    readonly offlineQueue: OfflineQueue | null;
+    /**
+     * @internal The underlying HTTP client — used by realtime and subscription layers.
+     * Not part of the public API. May change without notice between versions.
+     */
+    private readonly _httpClient;
+    constructor(config: CStarClientConfig);
+    /** Disconnect the realtime stream and clean up. */
+    destroy(): void;
+    /** Whether this client is using test mode keys (sk_test_* or pk_test_*). */
+    get isTestMode(): boolean;
+    /**
+     * Validate the configured API key and return the team + key metadata it
+     * resolves to. Useful for confirming the key is wired up correctly during
+     * onboarding (and for AI assistants that want a one-call sanity check).
+     *
+     * Closes F-018.
+     *
+     * ```ts
+     * const me = await cstar.whoami();
+     * console.log(me.teamSlug, me.environment); // 'acme', 'test'
+     * ```
+     */
+    whoami(): Promise<{
+        teamId: string;
+        teamName: string;
+        teamSlug: string;
+        keyId: string;
+        keyType: 'secret' | 'publishable';
+        environment: 'live' | 'test';
+        createdAt: string;
+        subscriptionStatus: string;
+    }>;
+    /**
+     * Side-channel metadata from the most recent HTTP response. Holds the
+     * server `requestId` (for support escalations), `timestamp`, and the
+     * `pagination` info from list endpoints. Reset on every call — read it
+     * immediately after awaiting the call you care about.
+     *
+     * ```ts
+     * const ticket = await cstar.tickets.create({...});
+     * console.error('Created', ticket.id, 'request:', cstar.lastMeta.requestId);
+     * ```
+     */
+    get lastMeta(): LastMeta;
+}
+
+export { type Achievement, type AchievementListParams, type ActivityEvent, type ActivityListParams, type AiAction, type AiActionParams, type AiActionResult, type AnalyticsOverview, type AnalyticsParams, type ApiErrorBody, type ApiResponse, type Article, type ArticleCreateParams, type ArticleListParams, type ArticleUpdateParams, type Attachment, type AttachmentListParams, type AuditLogEntry, type AuditLogListParams, type AutomationAction, type AutomationCondition, type AutomationConditions, type AutomationCreateParams, type AutomationExecution, type AutomationExecutionListParams, type AutomationListParams, type AutomationRule, type AutomationTestResult, type AutomationUpdateParams, type BillingPortal, type BillingPortalParams, type Boss, type BossDamageParams, type BossDamageResult, type BossDefeat, type BossDefeatListParams, type BossSpawnParams, type BulkDeleteParams, type BulkResult, type BulkUpdateParams, type BusinessHours, type BusinessHoursUpdateParams, CStarAuthenticationError, CStarClient, type CStarClientConfig, CStarConflictError, CStarError, CStarFeatureDisabledError, CStarNotFoundError, CStarPermissionError, CStarRateLimitError, CStarRealtime, CStarServerError, CStarValidationError, type Category, type CategoryCreateParams, type CategoryListParams, type CategoryUpdateParams, type CommunityComment, type CommunityCommentCreateParams, type CommunityPost, type CommunityPostCreateParams, type CommunityPostListParams, type CommunityPostUpdateParams, type CommunityTopic, type ConnectionHandler, type Cosmetic, type CosmeticPreferences, type CsatSettings, type CsatSettingsUpdateParams, type CsatStats, type CsatSurvey, type CsatSurveyCreateParams, type CsatSurveyListParams, type CustomField, type CustomFieldCreateParams, type CustomFieldListParams, type CustomFieldUpdateParams, type Customer, type CustomerCreateParams, type CustomerGroup, type CustomerGroupAddMembersParams, type CustomerGroupAddResult, type CustomerGroupCreateParams, type CustomerGroupListParams, type CustomerGroupMemberListParams, type CustomerGroupMembersResult, type CustomerGroupRemoveResult, type CustomerGroupUpdateParams, type CustomerListParams, type CustomerUpdateParams, type DeleteResponse, type ErrorHandler, ErrorType, type EventHandler, type ExportCreateParams, type ExportResult, type GameConfig, type HighFive, type HighFiveCanSend, type HighFiveCreateParams, type HighFiveListParams, type ImportCreateParams, type ImportLog, type ImportLogListParams, type ImportResult, type Invite, type InviteCreateParams, type InviteListParams, type LeaderboardEntry, type LeaderboardParams, type ListResponse, type Member, type MemberListParams, type MemberUpdateParams, type Mention, type MentionListParams, type MentionUnreadCount, type Message, type MessageCreateParams, type Metadata, type Notification, type NotificationListParams, OfflineQueue, type OfflineQueueOptions, type OneUp, type OneUpCreateParams, type OneUpListParams, type OneUpRemaining, type PaginationInfo, type PaginationParams, type Player, type Puzzle, type PuzzleCompleteParams, type PuzzleCompleteResult, type PuzzleStreak, type Quest, type QueueItem, type QueueResult, type QuickReply, type QuickReplyCreateParams, type QuickReplyUpdateParams, type RealtimeEvent, type RealtimeOptions, type RequestOptions, type SavedView, type SearchParams, type SearchResult, type Season, type SeasonStats, type SkillAllocateParams, type SkillAllocateResult, type SkillTree, type SlaMetrics, type SlaMetricsParams, type SlaRule, type SlaRuleCreateParams, type SlaRuleListParams, type SlaRuleUpdateParams, type StatusCreateParams, type StatusUpdateParams, Subscription$1 as Subscription, type Tag, type TagListParams, type TeamSettings, type TeamSettingsUpdateParams, type Ticket, type TicketCreateParams, type TicketCustomerSummary, type TicketListParams, type TicketStatus, type TicketUpdateParams, type TopicCustomField, type UnreadCount, type ViewCreateParams, type ViewExecuteParams, type ViewListParams, type ViewUpdateParams, type Webhook, type WebhookCreateParams, type WebhookEvent, type WebhookEventData, type WebhookEventType, type WebhookListParams, type WebhookListener, type WebhookListenerParams, type WebhookSubscribeParams, type WebhookSubscription, type WebhookTestResult, type WebhookTriggerTestParams, type WebhookTriggerTestResult, type WebhookUpdateParams, type WidgetSettings, type WidgetSettingsUpdateParams };