@cossistant/core 0.0.7

package/dist/logger.d.ts

@@ -0,0 +1,11 @@
+//#region src/logger.d.ts
+type LogMethod = (message: string, ...details: unknown[]) => void;
+declare const logger: {
+  debug: LogMethod;
+  info: LogMethod;
+  warn: LogMethod;
+  error: LogMethod;
+};
+//#endregion
+export { logger };
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../src/logger.ts"],"sourcesContent":[],"mappings":";KAIK,SAAA;AAAA,cAsBQ,MAtBC,EAAA;EAsBD,KAAA,WAKZ"}

package/dist/logger.js

@@ -0,0 +1,22 @@
+//#region src/logger.ts
+const LOG_PREFIX = "[cossistant]";
+const resolveConsole = () => {
+	if (typeof globalThis === "undefined") return null;
+	return globalThis.console ?? null;
+};
+const createLoggerMethod = (level) => (message, ...details) => {
+	const target = resolveConsole();
+	if (!target) return;
+	const consoleMethod = (target[level] ?? target.log)?.bind(target);
+	consoleMethod?.(LOG_PREFIX, message, ...details);
+};
+const logger = {
+	debug: createLoggerMethod("debug"),
+	info: createLoggerMethod("info"),
+	warn: createLoggerMethod("warn"),
+	error: createLoggerMethod("error")
+};
+
+//#endregion
+export { logger };
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":[],"sources":["../src/logger.ts"],"sourcesContent":["const LOG_PREFIX = \"[cossistant]\";\n\ntype LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\";\n\ntype LogMethod = (message: string, ...details: unknown[]) => void;\n\nconst resolveConsole = (): Console | null => {\n\tif (typeof globalThis === \"undefined\") {\n\t\treturn null;\n\t}\n\n\treturn globalThis.console ?? null;\n};\n\nconst createLoggerMethod =\n\t(level: LogLevel): LogMethod =>\n\t(message, ...details) => {\n\t\tconst target = resolveConsole();\n\t\tif (!target) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst consoleMethod = (target[level] ?? target.log)?.bind(target);\n\t\tconsoleMethod?.(LOG_PREFIX, message, ...details);\n\t};\n\nexport const logger = {\n\tdebug: createLoggerMethod(\"debug\"),\n\tinfo: createLoggerMethod(\"info\"),\n\twarn: createLoggerMethod(\"warn\"),\n\terror: createLoggerMethod(\"error\"),\n};\n"],"mappings":";AAAA,MAAM,aAAa;AAMnB,MAAM,uBAAuC;AAC5C,KAAI,OAAO,eAAe,YACzB,QAAO;AAGR,QAAO,WAAW,WAAW;;AAG9B,MAAM,sBACJ,WACA,SAAS,GAAG,YAAY;CACxB,MAAM,SAAS,gBAAgB;AAC/B,KAAI,CAAC,OACJ;CAGD,MAAM,iBAAiB,OAAO,UAAU,OAAO,MAAM,KAAK,OAAO;AACjE,iBAAgB,YAAY,SAAS,GAAG,QAAQ;;AAGlD,MAAa,SAAS;CACrB,OAAO,mBAAmB,QAAQ;CAClC,MAAM,mBAAmB,OAAO;CAChC,MAAM,mBAAmB,OAAO;CAChC,OAAO,mBAAmB,QAAQ;CAClC"}

package/dist/realtime-events.d.ts

@@ -0,0 +1,120 @@
+import { z } from "zod";
+
+//#region ../types/src/realtime-events.d.ts
+
+/**
+ * Central event system for real-time communication
+ * All WebSocket and Redis Pub/Sub events are defined here
+ */
+declare const realtimeSchema: {
+  readonly userConnected: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    visitorId: z.ZodNullable<z.ZodString>;
+    userId: z.ZodNullable<z.ZodString>;
+    connectionId: z.ZodString;
+  }, z.core.$strip>;
+  readonly userDisconnected: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    visitorId: z.ZodNullable<z.ZodString>;
+    userId: z.ZodNullable<z.ZodString>;
+    connectionId: z.ZodString;
+  }, z.core.$strip>;
+  readonly visitorConnected: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    userId: z.ZodNullable<z.ZodString>;
+    visitorId: z.ZodString;
+    connectionId: z.ZodString;
+  }, z.core.$strip>;
+  readonly visitorDisconnected: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    userId: z.ZodNullable<z.ZodString>;
+    visitorId: z.ZodString;
+    connectionId: z.ZodString;
+  }, z.core.$strip>;
+  readonly userPresenceUpdate: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    visitorId: z.ZodNullable<z.ZodString>;
+    userId: z.ZodString;
+    status: z.ZodEnum<{
+      online: "online";
+      away: "away";
+      offline: "offline";
+    }>;
+    lastSeen: z.ZodString;
+  }, z.core.$strip>;
+  readonly conversationSeen: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    visitorId: z.ZodNullable<z.ZodString>;
+    userId: z.ZodNullable<z.ZodString>;
+    conversationId: z.ZodString;
+    aiAgentId: z.ZodNullable<z.ZodString>;
+    lastSeenAt: z.ZodString;
+  }, z.core.$strip>;
+  readonly conversationTyping: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    visitorId: z.ZodNullable<z.ZodString>;
+    userId: z.ZodNullable<z.ZodString>;
+    conversationId: z.ZodString;
+    aiAgentId: z.ZodNullable<z.ZodString>;
+    isTyping: z.ZodBoolean;
+    visitorPreview: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  }, z.core.$strip>;
+  readonly timelineItemCreated: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    visitorId: z.ZodNullable<z.ZodString>;
+    userId: z.ZodNullable<z.ZodString>;
+    conversationId: z.ZodString;
+    item: z.ZodObject<{
+      id: z.ZodString;
+      conversationId: z.ZodString;
+      organizationId: z.ZodString;
+      visibility: z.ZodEnum<{
+        [x: string]: any;
+      }>;
+      type: z.ZodEnum<{
+        [x: string]: any;
+      }>;
+      text: z.ZodNullable<z.ZodString>;
+      parts: z.ZodArray<z.ZodUnknown>;
+      userId: z.ZodNullable<z.ZodString>;
+      visitorId: z.ZodNullable<z.ZodString>;
+      aiAgentId: z.ZodNullable<z.ZodString>;
+      createdAt: z.ZodString;
+      deletedAt: z.ZodNullable<z.ZodString>;
+      tool: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  readonly conversationCreated: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    visitorId: z.ZodNullable<z.ZodString>;
+    userId: z.ZodNullable<z.ZodString>;
+    conversationId: z.ZodString;
+    conversation: any;
+    header: any;
+  }, z.core.$strip>;
+  readonly visitorIdentified: z.ZodObject<{
+    websiteId: z.ZodString;
+    organizationId: z.ZodString;
+    userId: z.ZodNullable<z.ZodString>;
+    visitorId: z.ZodString;
+    visitor: any;
+  }, z.core.$strip>;
+};
+type RealtimeEventType = keyof typeof realtimeSchema;
+type RealtimeEventPayload<T extends RealtimeEventType> = z.infer<(typeof realtimeSchema)[T]>;
+type RealtimeEvent<T extends RealtimeEventType> = {
+  type: T;
+  payload: RealtimeEventPayload<T>;
+};
+//#endregion
+export { RealtimeEvent };
+//# sourceMappingURL=realtime-events.d.ts.map

package/dist/realtime-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime-events.d.ts","names":[],"sources":["../../types/src/realtime-events.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAiBa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmED,iBAAA,gBAAiC;KAEjC,+BAA+B,qBAAqB,CAAA,CAAE,cACzD,gBAAgB;KAGb,wBAAwB;QAC7B;WACG,qBAAqB"}

package/dist/rest-client.d.ts

@@ -0,0 +1,65 @@
+import { CreateConversationRequestBody, CreateConversationResponseBody, GetConversationRequest, GetConversationResponse, GetConversationSeenDataResponse, ListConversationsRequest, ListConversationsResponse, MarkConversationSeenRequestBody, MarkConversationSeenResponseBody, SetConversationTypingResponseBody } from "./conversation.js";
+import { GetConversationTimelineItemsRequest, GetConversationTimelineItemsResponse, SendTimelineItemRequest, SendTimelineItemResponse } from "./timeline-item.js";
+import { types_d_exports } from "./types.js";
+import { IdentifyContactResponse } from "./contact.js";
+
+//#region src/rest-client.d.ts
+declare class CossistantRestClient {
+  private config;
+  private baseHeaders;
+  private publicKey;
+  private websiteId;
+  private visitorId;
+  private visitorBlocked;
+  constructor(config: types_d_exports.CossistantConfig);
+  private normalizeVisitorResponse;
+  private resolveVisitorId;
+  private syncVisitorSnapshot;
+  private request;
+  getWebsite(): Promise<types_d_exports.PublicWebsiteResponse>;
+  setWebsiteContext(websiteId: string, visitorId?: string): void;
+  setVisitorBlocked(isBlocked: boolean): void;
+  getCurrentWebsiteId(): string | null;
+  getCurrentVisitorId(): string | null;
+  updateVisitorMetadata(metadata: types_d_exports.VisitorMetadata): Promise<types_d_exports.VisitorResponse>;
+  /**
+   * Identify a visitor by creating or updating their contact information
+   * This will link the visitor to a contact record that can be tracked across devices
+   */
+  identify(params: {
+    externalId?: string;
+    email?: string;
+    name?: string;
+    image?: string;
+    metadata?: Record<string, unknown>;
+    contactOrganizationId?: string;
+  }): Promise<IdentifyContactResponse>;
+  /**
+   * Update metadata for the contact associated with the current visitor
+   * Note: The visitor must be identified first via the identify() method
+   */
+  updateContactMetadata(metadata: Record<string, unknown>): Promise<types_d_exports.VisitorResponse>;
+  createConversation(params?: Partial<CreateConversationRequestBody>): Promise<CreateConversationResponseBody>;
+  updateConfiguration(config: Partial<types_d_exports.CossistantConfig>): Promise<void>;
+  listConversations(params?: Partial<ListConversationsRequest>): Promise<ListConversationsResponse>;
+  getConversation(params: GetConversationRequest): Promise<GetConversationResponse>;
+  markConversationSeen(params: {
+    conversationId: string;
+  } & Partial<MarkConversationSeenRequestBody>): Promise<MarkConversationSeenResponseBody>;
+  getConversationSeenData(params: {
+    conversationId: string;
+  }): Promise<GetConversationSeenDataResponse>;
+  setConversationTyping(params: {
+    conversationId: string;
+    isTyping: boolean;
+    visitorPreview?: string | null;
+    visitorId?: string;
+  }): Promise<SetConversationTypingResponseBody>;
+  sendMessage(params: SendTimelineItemRequest): Promise<SendTimelineItemResponse>;
+  getConversationTimelineItems(params: GetConversationTimelineItemsRequest & {
+    conversationId: string;
+  }): Promise<GetConversationTimelineItemsResponse>;
+}
+//#endregion
+export { CossistantRestClient };
+//# sourceMappingURL=rest-client.d.ts.map

package/dist/rest-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-client.d.ts","names":[],"sources":["../src/rest-client.ts"],"sourcesContent":[],"mappings":";;;;;;cAqCa,oBAAA;;EAAA,QAAA,WAAA;EAQQ,QAAA,SAAA;EA2LQ,QAAA,SAAA;EAAR,QAAA,SAAA;EA6ET,QAAA,cAAA;EACA,WAAA,CAAA,MAAA,EAzQS,eAAA,CAAA,gBAyQT;EAAR,QAAA,wBAAA;EAyBS,QAAA,gBAAA;EAEA,QAAA,mBAAA;EAAR,QAAA,OAAA;EAqCO,UAAA,CAAA,CAAA,EA9IS,OA8IT,CA9IiB,eAAA,CAAA,qBA8IjB,CAAA;EACA,iBAAA,CAAA,SAAA,EAAA,MAAA,EAAA,SAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAAR,iBAAA,CAAA,SAAA,EAAA,OAAA,CAAA,EAAA,IAAA;EAOc,mBAAA,CAAA,CAAA,EAAA,MAAA,GAAA,IAAA;EAAR,mBAAA,CAAA,CAAA,EAAA,MAAA,GAAA,IAAA;EACE,qBAAA,CAAA,QAAA,EA1EA,eAAA,CAAA,eA0EA,CAAA,EAzER,OAyEQ,CAzEA,eAAA,CAAA,eAyEA,CAAA;EAAR;;;;EAwEc,QAAA,CAAA,MAAA,EAAA;IAAR,UAAA,CAAA,EAAA,MAAA;IACE,KAAA,CAAA,EAAA,MAAA;IAAR,IAAA,CAAA,EAAA,MAAA;IAiEM,KAAA,CAAA,EAAA,MAAA;IACE,QAAA,CAAA,EA3LC,MA2LD,CAAA,MAAA,EAAA,OAAA,CAAA;IAAR,qBAAA,CAAA,EAAA,MAAA;EAgCU,CAAA,CAAA,EAzNT,OAyNS,CAzND,uBAyNC,CAAA;EAAR;;;;EAsCD,qBAAA,CAAA,QAAA,EA1NO,MA0NP,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAzND,OAyNC,CAzNO,eAAA,CAAA,eAyNP,CAAA;EAwBQ,kBAAA,CAAA,MAAA,CAAA,EA1OH,OA0OG,CA1OK,6BA0OL,CAAA,CAAA,EAzOT,OAyOS,CAzOD,8BAyOC,CAAA;EAAR,mBAAA,CAAA,MAAA,EAzL8B,OAyL9B,CAzLsC,eAAA,CAAA,gBAyLtC,CAAA,CAAA,EAzL0D,OAyL1D,CAAA,IAAA,CAAA;EA6CK,iBAAA,CAAA,MAAA,CAAA,EA9MA,OA8MA,CA9MQ,wBA8MR,CAAA,CAAA,EA7MN,OA6MM,CA7ME,yBA6MF,CAAA;EACE,eAAA,CAAA,MAAA,EA7IF,sBA6IE,CAAA,EA5IR,OA4IQ,CA5IA,uBA4IA,CAAA;EAAR,oBAAA,CAAA,MAAA,EAAA;IAsBM,cAAA,EAAA,MAAA;EACE,CAAA,GAnIN,OAmIM,CAnIE,+BAmIF,CAAA,CAAA,EAlIR,OAkIQ,CAlIA,gCAkIA,CAAA;EAAR,uBAAA,CAAA,MAAA,EAAA;IAAO,cAAA,EAAA,MAAA;MA7FN,QAAQ;;;;;;MAwBR,QAAQ;sBA6CH,0BACN,QAAQ;uCAsBF;;MACN,QAAQ"}

package/dist/rest-client.js

@@ -0,0 +1,367 @@
+import { logger } from "./logger.js";
+import { CossistantAPIError } from "./types.js";
+import { generateConversationId } from "./utils.js";
+import { collectVisitorData } from "./visitor-data.js";
+import { getExistingVisitorId, getVisitorId, setVisitorId } from "./visitor-tracker.js";
+
+//#region src/rest-client.ts
+var CossistantRestClient = class {
+	config;
+	baseHeaders;
+	publicKey;
+	websiteId = null;
+	visitorId = null;
+	visitorBlocked = false;
+	constructor(config) {
+		this.config = config;
+		this.publicKey = config.publicKey || (typeof process !== "undefined" ? process.env.NEXT_PUBLIC_COSSISTANT_KEY : void 0) || (typeof process !== "undefined" ? process.env.COSSISTANT_PUBLIC_KEY : void 0) || "";
+		if (!this.publicKey) throw new Error("Public key is required. Please provide it in the config or set NEXT_PUBLIC_COSSISTANT_KEY or COSSISTANT_PUBLIC_KEY environment variable.");
+		this.baseHeaders = {
+			"Content-Type": "application/json",
+			"X-Public-Key": this.publicKey
+		};
+		if (config.userId) this.baseHeaders["X-User-ID"] = config.userId;
+		if (config.organizationId) this.baseHeaders["X-Organization-ID"] = config.organizationId;
+	}
+	normalizeVisitorResponse(payload) {
+		payload.contact && payload.contact;
+		return {
+			...payload,
+			latitude: typeof payload.latitude === "string" ? Number.parseFloat(payload.latitude) : payload.latitude,
+			longitude: typeof payload.longitude === "string" ? Number.parseFloat(payload.longitude) : payload.longitude,
+			createdAt: payload.createdAt,
+			updatedAt: payload.updatedAt,
+			lastSeenAt: payload.lastSeenAt ? payload.lastSeenAt : null,
+			blockedAt: payload.blockedAt ? payload.blockedAt : null,
+			contact: payload.contact ? payload.contact : null
+		};
+	}
+	resolveVisitorId() {
+		if (this.visitorId) return this.visitorId;
+		if (this.websiteId) {
+			const storedVisitorId = getVisitorId(this.websiteId);
+			if (storedVisitorId) {
+				this.visitorId = storedVisitorId;
+				return storedVisitorId;
+			}
+		}
+		throw new Error("Visitor ID is required");
+	}
+	async syncVisitorSnapshot(visitorId) {
+		try {
+			const visitorData = await collectVisitorData();
+			if (!visitorData) return;
+			const payload = Object.entries(visitorData).reduce((acc, [key, value]) => {
+				if (value === null || value === void 0) return acc;
+				acc[key] = value;
+				return acc;
+			}, {});
+			if (Object.keys(payload).length === 0) return;
+			await this.request(`/visitors/${visitorId}`, {
+				method: "PATCH",
+				body: JSON.stringify(payload),
+				headers: { "X-Visitor-Id": visitorId }
+			});
+		} catch (error) {
+			logger.warn("Failed to sync visitor data", error);
+		}
+	}
+	async request(path, options = {}) {
+		if (this.visitorBlocked) {
+			const method = (options.method ?? "GET").toUpperCase();
+			const [rawPath] = path.split("?");
+			if (!((rawPath.endsWith("/") ? rawPath.slice(0, -1) : rawPath) === "/websites" && (method === "GET" || method === "HEAD"))) throw new CossistantAPIError({
+				code: "VISITOR_BLOCKED",
+				message: "Visitor is blocked and cannot perform this action.",
+				details: {
+					path,
+					method
+				}
+			});
+		}
+		const url = `${this.config.apiUrl}${path}`;
+		const response = await fetch(url, {
+			...options,
+			headers: {
+				...this.baseHeaders,
+				...options.headers
+			}
+		});
+		if (!response.ok) {
+			const errorData = await response.json().catch(() => ({}));
+			const statusCode = response.status;
+			const errorCode = errorData.code || `HTTP_${statusCode}`;
+			const serverMessage = errorData.message;
+			const isAuthError = statusCode === 401 || statusCode === 403 || errorCode === "UNAUTHORIZED" || errorCode === "FORBIDDEN" || errorCode === "INVALID_API_KEY" || errorCode === "API_KEY_EXPIRED" || errorCode === "API_KEY_MISSING" || errorCode?.toUpperCase().includes("AUTH") || errorCode?.toUpperCase().includes("API_KEY");
+			const errorMessage = isAuthError ? "Your Cossistant public API key is invalid, expired, missing or not authorized to access this resource." : serverMessage || `Request failed with status ${statusCode}`;
+			if (isAuthError) logger.error(errorMessage, {
+				details: errorData.details,
+				path,
+				status: statusCode,
+				code: errorCode
+			});
+			else logger.error("API request failed", {
+				message: errorMessage,
+				details: errorData.details,
+				path,
+				status: statusCode,
+				code: errorCode
+			});
+			throw new CossistantAPIError({
+				code: errorCode,
+				message: errorMessage,
+				details: errorData.details
+			});
+		}
+		return response.json();
+	}
+	async getWebsite() {
+		const headers = {};
+		if (this.websiteId) {
+			const storedVisitorId = getVisitorId(this.websiteId);
+			if (storedVisitorId) headers["X-Visitor-Id"] = storedVisitorId;
+		} else {
+			const existingVisitor = getExistingVisitorId(this.publicKey);
+			if (existingVisitor) {
+				headers["X-Visitor-Id"] = existingVisitor.visitorId;
+				this.websiteId = existingVisitor.websiteId;
+				this.visitorId = existingVisitor.visitorId;
+			}
+		}
+		const response = await this.request("/websites", { headers });
+		this.websiteId = response.id;
+		this.visitorBlocked = response.visitor?.isBlocked ?? false;
+		if (response.visitor?.id) {
+			if (this.visitorBlocked) {
+				this.visitorId = response.visitor.id;
+				setVisitorId(response.id, response.visitor.id);
+				return response;
+			}
+			this.visitorId = response.visitor.id;
+			setVisitorId(response.id, response.visitor.id);
+			this.syncVisitorSnapshot(response.visitor.id);
+		}
+		return response;
+	}
+	setWebsiteContext(websiteId, visitorId) {
+		this.websiteId = websiteId;
+		if (visitorId) {
+			this.visitorId = visitorId;
+			setVisitorId(websiteId, visitorId);
+		}
+	}
+	setVisitorBlocked(isBlocked) {
+		this.visitorBlocked = isBlocked;
+	}
+	getCurrentWebsiteId() {
+		return this.websiteId;
+	}
+	getCurrentVisitorId() {
+		if (this.visitorId) return this.visitorId;
+		if (!this.websiteId) return null;
+		return getVisitorId(this.websiteId) ?? null;
+	}
+	async updateVisitorMetadata(metadata) {
+		const visitorId = this.resolveVisitorId();
+		const response = await this.request(`/visitors/${visitorId}/metadata`, {
+			method: "PATCH",
+			body: JSON.stringify({ metadata }),
+			headers: { "X-Visitor-Id": visitorId }
+		});
+		return this.normalizeVisitorResponse(response);
+	}
+	/**
+	* Identify a visitor by creating or updating their contact information
+	* This will link the visitor to a contact record that can be tracked across devices
+	*/
+	async identify(params) {
+		const visitorId = this.resolveVisitorId();
+		const response = await this.request("/contacts/identify", {
+			method: "POST",
+			body: JSON.stringify({
+				visitorId,
+				...params
+			}),
+			headers: { "X-Visitor-Id": visitorId }
+		});
+		return {
+			contact: {
+				...response.contact,
+				metadata: typeof response.contact.metadata === "string" ? JSON.parse(response.contact.metadata) : response.contact.metadata,
+				createdAt: response.contact.createdAt,
+				updatedAt: response.contact.updatedAt
+			},
+			visitorId: response.visitorId
+		};
+	}
+	/**
+	* Update metadata for the contact associated with the current visitor
+	* Note: The visitor must be identified first via the identify() method
+	*/
+	async updateContactMetadata(metadata) {
+		return this.updateVisitorMetadata(metadata);
+	}
+	async createConversation(params = {}) {
+		const conversationId = params.conversationId || generateConversationId();
+		const storedVisitorId = this.websiteId ? getVisitorId(this.websiteId) : void 0;
+		const visitorId = params.visitorId || storedVisitorId;
+		if (!visitorId) throw new Error("Visitor ID is required");
+		const body = {
+			conversationId,
+			visitorId,
+			defaultTimelineItems: params.defaultTimelineItems || [],
+			channel: params.channel || "widget"
+		};
+		const headers = {};
+		if (visitorId) headers["X-Visitor-Id"] = visitorId;
+		const response = await this.request("/conversations", {
+			method: "POST",
+			body: JSON.stringify(body),
+			headers
+		});
+		return {
+			conversation: {
+				...response.conversation,
+				createdAt: response.conversation.createdAt,
+				updatedAt: response.conversation.updatedAt,
+				deletedAt: response.conversation.deletedAt ?? null,
+				lastTimelineItem: response.conversation.lastTimelineItem
+			},
+			initialTimelineItems: response.initialTimelineItems
+		};
+	}
+	async updateConfiguration(config) {
+		if (config.publicKey) {
+			this.publicKey = config.publicKey;
+			this.baseHeaders["X-Public-Key"] = config.publicKey;
+		}
+		if (config.userId) this.baseHeaders["X-User-ID"] = config.userId;
+		else if (config.userId === null) {
+			const { "X-User-ID": _,...rest } = this.baseHeaders;
+			this.baseHeaders = rest;
+		}
+		if (config.organizationId) this.baseHeaders["X-Organization-ID"] = config.organizationId;
+		else if (config.organizationId === null) {
+			const { "X-Organization-ID": _,...rest } = this.baseHeaders;
+			this.baseHeaders = rest;
+		}
+		this.config = {
+			...this.config,
+			...config
+		};
+	}
+	async listConversations(params = {}) {
+		const storedVisitorId = this.websiteId ? getVisitorId(this.websiteId) : void 0;
+		const visitorId = params.visitorId || storedVisitorId;
+		if (!visitorId) throw new Error("Visitor ID is required");
+		const queryParams = new URLSearchParams();
+		if (visitorId) queryParams.set("visitorId", visitorId);
+		if (params.page) queryParams.set("page", params.page.toString());
+		if (params.limit) queryParams.set("limit", params.limit.toString());
+		if (params.status) queryParams.set("status", params.status);
+		if (params.orderBy) queryParams.set("orderBy", params.orderBy);
+		if (params.order) queryParams.set("order", params.order);
+		const headers = {};
+		if (visitorId) headers["X-Visitor-Id"] = visitorId;
+		const response = await this.request(`/conversations?${queryParams.toString()}`, { headers });
+		return {
+			conversations: response.conversations.map((conv) => ({
+				...conv,
+				createdAt: conv.createdAt,
+				updatedAt: conv.updatedAt,
+				deletedAt: conv.deletedAt ?? null,
+				lastTimelineItem: conv.lastTimelineItem
+			})),
+			pagination: response.pagination
+		};
+	}
+	async getConversation(params) {
+		const visitorId = this.websiteId ? getVisitorId(this.websiteId) : void 0;
+		const headers = {};
+		if (visitorId) headers["X-Visitor-Id"] = visitorId;
+		const response = await this.request(`/conversations/${params.conversationId}`, { headers });
+		return { conversation: {
+			...response.conversation,
+			createdAt: response.conversation.createdAt,
+			updatedAt: response.conversation.updatedAt,
+			deletedAt: response.conversation.deletedAt ?? null,
+			lastTimelineItem: response.conversation.lastTimelineItem
+		} };
+	}
+	async markConversationSeen(params) {
+		const storedVisitorId = this.websiteId ? getVisitorId(this.websiteId) : void 0;
+		const visitorId = params.visitorId || storedVisitorId;
+		if (!visitorId) throw new Error("Visitor ID is required to mark a conversation as seen");
+		const headers = {};
+		if (visitorId) headers["X-Visitor-Id"] = visitorId;
+		const body = {};
+		if (params.visitorId) body.visitorId = params.visitorId;
+		const response = await this.request(`/conversations/${params.conversationId}/seen`, {
+			method: "POST",
+			body: JSON.stringify(body),
+			headers
+		});
+		return {
+			conversationId: response.conversationId,
+			lastSeenAt: response.lastSeenAt
+		};
+	}
+	async getConversationSeenData(params) {
+		return { seenData: (await this.request(`/conversations/${params.conversationId}/seen`, { method: "GET" })).seenData.map((item) => ({
+			...item,
+			lastSeenAt: item.lastSeenAt,
+			createdAt: item.createdAt,
+			updatedAt: item.updatedAt,
+			deletedAt: item.deletedAt ? item.deletedAt : null
+		})) };
+	}
+	async setConversationTyping(params) {
+		const storedVisitorId = this.websiteId ? getVisitorId(this.websiteId) : void 0;
+		const visitorId = params.visitorId || storedVisitorId;
+		if (!visitorId) throw new Error("Visitor ID is required to report typing state");
+		const headers = {};
+		if (visitorId) headers["X-Visitor-Id"] = visitorId;
+		const body = { isTyping: params.isTyping };
+		if (params.visitorId) body.visitorId = params.visitorId;
+		if (params.visitorPreview && params.isTyping) body.visitorPreview = params.visitorPreview.slice(0, 2e3);
+		const response = await this.request(`/conversations/${params.conversationId}/typing`, {
+			method: "POST",
+			body: JSON.stringify(body),
+			headers
+		});
+		return {
+			conversationId: response.conversationId,
+			isTyping: response.isTyping,
+			visitorPreview: response.visitorPreview,
+			sentAt: response.sentAt
+		};
+	}
+	async sendMessage(params) {
+		const visitorId = this.websiteId ? getVisitorId(this.websiteId) : void 0;
+		const headers = {};
+		if (visitorId) headers["X-Visitor-Id"] = visitorId;
+		return { item: (await this.request("/messages", {
+			method: "POST",
+			body: JSON.stringify(params),
+			headers
+		})).item };
+	}
+	async getConversationTimelineItems(params) {
+		const visitorId = this.websiteId ? getVisitorId(this.websiteId) : void 0;
+		const queryParams = new URLSearchParams();
+		if (params.limit) queryParams.set("limit", params.limit.toString());
+		if (params.cursor) queryParams.set("cursor", params.cursor);
+		const headers = {};
+		if (visitorId) headers["X-Visitor-Id"] = visitorId;
+		const response = await this.request(`/conversations/${params.conversationId}/timeline?${queryParams.toString()}`, { headers });
+		return {
+			items: response.items,
+			nextCursor: response.nextCursor,
+			hasNextPage: response.hasNextPage
+		};
+	}
+};
+
+//#endregion
+export { CossistantRestClient };
+//# sourceMappingURL=rest-client.js.map