@linqapp/sdk 0.1.5 → 0.4.0

package/src/client.ts

@@ -11,8 +11,17 @@ import type { APIResponseProps } from './internal/parse';
 import { getPlatformHeaders } from './internal/detect-platform';
 import * as Shims from './internal/shims';
 import * as Opts from './internal/request-options';
+import { stringifyQuery } from './internal/utils/query';
 import { VERSION } from './version';
 import * as Errors from './core/error';
+import * as Pagination from './core/pagination';
+import {
+  AbstractPage,
+  type ListChatsPaginationParams,
+  ListChatsPaginationResponse,
+  type ListMessagesPaginationParams,
+  ListMessagesPaginationResponse,
+} from './core/pagination';
 import * as Uploads from './core/uploads';
 import * as API from './resources/index';
 import { APIPromise } from './core/api-promise';
@@ -25,26 +34,25 @@ import {
 } from './resources/attachments';
 import {
   Capability,
-  CapabilityCheckImessageParams,
-  CapabilityCheckImessageResponse,
-  CapabilityCheckRcsParams,
-  CapabilityCheckRcsResponse,
+  CapabilityCheckRCSParams,
+  CapabilityCheckRCSResponse,
+  CapabilityCheckiMessageParams,
+  CapabilityCheckiMessageResponse,
 } from './resources/capability';
 import {
   ChatHandle,
-  MediaPart,
   Message,
   MessageAddReactionParams,
   MessageAddReactionResponse,
   MessageDeleteParams,
   MessageEffect,
-  MessageRetrieveThreadParams,
-  MessageRetrieveThreadResponse,
+  MessageListMessagesThreadParams,
+  MessageUpdateParams,
   Messages,
+  MessagesListMessagesPagination,
   Reaction,
   ReactionType,
   ReplyTo,
-  TextPart,
 } from './resources/messages';
 import { PhoneNumberListResponse, PhoneNumbers } from './resources/phone-numbers';
 import { PhonenumberListResponse, Phonenumbers } from './resources/phonenumbers';
@@ -57,17 +65,63 @@ import {
   WebhookSubscriptionUpdateParams,
   WebhookSubscriptions,
 } from './resources/webhook-subscriptions';
+import {
+  ChatCreatedV2025WebhookEvent,
+  ChatCreatedV2026WebhookEvent,
+  ChatGroupIconUpdateFailedV2025WebhookEvent,
+  ChatGroupIconUpdateFailedV2026WebhookEvent,
+  ChatGroupIconUpdatedV2025WebhookEvent,
+  ChatGroupIconUpdatedV2026WebhookEvent,
+  ChatGroupNameUpdateFailedV2025WebhookEvent,
+  ChatGroupNameUpdateFailedV2026WebhookEvent,
+  ChatGroupNameUpdatedV2025WebhookEvent,
+  ChatGroupNameUpdatedV2026WebhookEvent,
+  ChatTypingIndicatorStartedV2025WebhookEvent,
+  ChatTypingIndicatorStartedV2026WebhookEvent,
+  ChatTypingIndicatorStoppedV2025WebhookEvent,
+  ChatTypingIndicatorStoppedV2026WebhookEvent,
+  EventsWebhookEvent,
+  MessageDeliveredV2025WebhookEvent,
+  MessageDeliveredV2026WebhookEvent,
+  MessageEventV2,
+  MessageFailedV2025WebhookEvent,
+  MessageFailedV2026WebhookEvent,
+  MessagePayload,
+  MessageReadV2025WebhookEvent,
+  MessageReadV2026WebhookEvent,
+  MessageReceivedV2025WebhookEvent,
+  MessageReceivedV2026WebhookEvent,
+  MessageSentV2025WebhookEvent,
+  MessageSentV2026WebhookEvent,
+  ParticipantAddedV2025WebhookEvent,
+  ParticipantAddedV2026WebhookEvent,
+  ParticipantRemovedV2025WebhookEvent,
+  ParticipantRemovedV2026WebhookEvent,
+  PhoneNumberStatusUpdatedV2025WebhookEvent,
+  PhoneNumberStatusUpdatedV2026WebhookEvent,
+  ReactionAddedV2025WebhookEvent,
+  ReactionAddedV2026WebhookEvent,
+  ReactionEventBase,
+  ReactionRemovedV2025WebhookEvent,
+  ReactionRemovedV2026WebhookEvent,
+  SchemasMediaPartResponse,
+  SchemasMessageEffect,
+  SchemasTextPartResponse,
+  Webhooks,
+} from './resources/webhooks';
 import {
   Chat,
   ChatCreateParams,
   ChatCreateResponse,
-  ChatListParams,
-  ChatListResponse,
+  ChatListChatsParams,
   ChatSendVoicememoParams,
   ChatSendVoicememoResponse,
   ChatUpdateParams,
   Chats,
+  ChatsListChatsPagination,
+  MediaPart,
   MessageContent,
+  TextPart,
 } from './resources/chats/chats';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
@@ -268,21 +322,8 @@ export class LinqAPIV3 {
   /**
    * Basic re-implementation of `qs.stringify` for primitive types.
    */
-  protected stringifyQuery(query: Record<string, unknown>): string {
-    return Object.entries(query)
-      .filter(([_, value]) => typeof value !== 'undefined')
-      .map(([key, value]) => {
-        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-          return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-        }
-        if (value === null) {
-          return `${encodeURIComponent(key)}=`;
-        }
-        throw new Errors.LinqAPIV3Error(
-          `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
-        );
-      })
-      .join('&');
+  protected stringifyQuery(query: object | Record<string, unknown>): string {
+    return stringifyQuery(query);
   }
 
   private getUserAgent(): string {
@@ -319,7 +360,7 @@ export class LinqAPIV3 {
     }
 
     if (typeof query === 'object' && query && !Array.isArray(query)) {
-      url.search = this.stringifyQuery(query as Record<string, unknown>);
+      url.search = this.stringifyQuery(query);
     }
 
     return url.toString();
@@ -537,6 +578,30 @@ export class LinqAPIV3 {
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
 
+  getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(
+    path: string,
+    Page: new (...args: any[]) => PageClass,
+    opts?: PromiseOrValue<RequestOptions>,
+  ): Pagination.PagePromise<PageClass, Item> {
+    return this.requestAPIList(
+      Page,
+      opts && 'then' in opts ?
+        opts.then((opts) => ({ method: 'get', path, ...opts }))
+      : { method: 'get', path, ...opts },
+    );
+  }
+
+  requestAPIList<
+    Item = unknown,
+    PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>,
+  >(
+    Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass,
+    options: PromiseOrValue<FinalRequestOptions>,
+  ): Pagination.PagePromise<PageClass, Item> {
+    const request = this.makeRequest(options, null, undefined);
+    return new Pagination.PagePromise<PageClass, Item>(this as any as LinqAPIV3, request, Page);
+  }
+
   async fetchWithTimeout(
     url: RequestInfo,
     init: RequestInit | undefined,
@@ -758,7 +823,7 @@ export class LinqAPIV3 {
     ) {
       return {
         bodyHeaders: { 'content-type': 'application/x-www-form-urlencoded' },
-        body: this.stringifyQuery(body as Record<string, unknown>),
+        body: this.stringifyQuery(body),
       };
     } else {
       return this.#encoder({ body, headers });
@@ -785,13 +850,293 @@ export class LinqAPIV3 {
   static toFile = Uploads.toFile;
 
   chats: API.Chats = new API.Chats(this);
+  /**
+   * Messages are individual text or multimedia communications within a chat thread.
+   *
+   * Messages can include text, attachments, special effects (like confetti or fireworks),
+   * and reactions. All messages are associated with a specific chat and sent from a
+   * phone number you own.
+   *
+   * Messages support delivery status tracking, read receipts, and editing capabilities.
+   *
+   */
   messages: API.Messages = new API.Messages(this);
+  /**
+   * Send files (images, videos, documents, audio) with messages by providing a URL in a media part.
+   * Pre-uploading via `POST /v3/attachments` is **optional** and only needed for specific optimization scenarios.
+   *
+   * ## Sending Media via URL (up to 10MB)
+   *
+   * Provide a publicly accessible HTTPS URL with a [supported media type](#supported-file-types) in the `url` field of a media part.
+   *
+   * ```json
+   * {
+   *   "parts": [
+   *     { "type": "media", "url": "https://your-cdn.com/images/photo.jpg" }
+   *   ]
+   * }
+   * ```
+   *
+   * This works with any URL you already host — no pre-upload step required. **Maximum file size: 10MB.**
+   *
+   * ## Pre-Upload (required for files over 10MB)
+   *
+   * Use `POST /v3/attachments` when you want to:
+   * - **Send files larger than 10MB** (up to 100MB) — URL-based downloads are limited to 10MB
+   * - **Send the same file to many recipients** — upload once, reuse the `attachment_id` without re-downloading each time
+   * - **Reduce message send latency** — the file is already stored, so sending is faster
+   *
+   * **How it works:**
+   * 1. `POST /v3/attachments` with file metadata → returns a presigned `upload_url` (valid for **15 minutes**) and a permanent `attachment_id`
+   * 2. PUT the raw file bytes to the `upload_url` with the `required_headers` (no JSON or multipart — just the binary content)
+   * 3. Reference the `attachment_id` in your media part when sending messages (no expiration)
+   *
+   * **Key difference:** When you provide an external `url`, we download and process the file on every send.
+   * When you use a pre-uploaded `attachment_id`, the file is already stored — so repeated sends skip the download step entirely.
+   *
+   * ## Domain Allowlisting
+   *
+   * Attachment URLs in API responses are served from `cdn.linqapp.com`. This includes:
+   * - `url` fields in media and voice memo message parts
+   * - `download_url` fields in attachment and upload response objects
+   *
+   * If your application enforces domain allowlists (e.g., for SSRF protection), add:
+   *
+   * ```
+   * cdn.linqapp.com
+   * ```
+   *
+   * ## Supported File Types
+   *
+   * - **Images:** JPEG, PNG, GIF, HEIC, HEIF, TIFF, BMP
+   * - **Videos:** MP4, MOV, M4V
+   * - **Audio:** M4A, AAC, MP3, WAV, AIFF, CAF, AMR
+   * - **Documents:** PDF, TXT, RTF, CSV, Office formats, ZIP
+   * - **Contact & Calendar:** VCF, ICS
+   *
+   * ## Audio: Attachment vs Voice Memo
+   *
+   * Audio files sent as media parts appear as **downloadable file attachments** in iMessage.
+   * To send audio as an **iMessage voice memo bubble** (with native inline playback UI),
+   * use the dedicated `POST /v3/chats/{chatId}/voicememo` endpoint instead.
+   *
+   * ## File Size Limits
+   *
+   * - **URL-based (`url` field):** 10MB maximum
+   * - **Pre-upload (`attachment_id`):** 100MB maximum
+   *
+   */
   attachments: API.Attachments = new API.Attachments(this);
+  /**
+   * Phone Numbers represent the phone numbers assigned to your partner account.
+   *
+   * Use the list phone numbers endpoint to discover which phone numbers are available
+   * for sending messages.
+   *
+   * When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+   * in the `from` field.
+   *
+   */
   phonenumbers: API.Phonenumbers = new API.Phonenumbers(this);
+  /**
+   * Phone Numbers represent the phone numbers assigned to your partner account.
+   *
+   * Use the list phone numbers endpoint to discover which phone numbers are available
+   * for sending messages.
+   *
+   * When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+   * in the `from` field.
+   *
+   */
   phoneNumbers: API.PhoneNumbers = new API.PhoneNumbers(this);
+  /**
+   * Webhook Subscriptions allow you to receive real-time notifications when events
+   * occur on your account.
+   *
+   * Configure webhook endpoints to receive events such as messages sent/received,
+   * delivery status changes, reactions, typing indicators, and more.
+   *
+   * Failed deliveries (5xx, 429, network errors) are retried up to 10 times over
+   * ~2 hours with exponential backoff. Each event includes a unique ID for
+   * deduplication.
+   *
+   * ## Webhook Headers
+   *
+   * Each webhook request includes the following headers:
+   *
+   * | Header | Description |
+   * |--------|-------------|
+   * | `X-Webhook-Event` | The event type (e.g., `message.sent`, `message.received`) |
+   * | `X-Webhook-Subscription-ID` | Your webhook subscription ID |
+   * | `X-Webhook-Timestamp` | Unix timestamp (seconds) when the webhook was sent |
+   * | `X-Webhook-Signature` | HMAC-SHA256 signature for verification |
+   *
+   * ## Verifying Webhook Signatures
+   *
+   * All webhooks are signed using HMAC-SHA256. You should always verify the signature
+   * to ensure the webhook originated from Linq and hasn't been tampered with.
+   *
+   * **Signature Construction:**
+   *
+   * The signature is computed over a concatenation of the timestamp and payload:
+   *
+   * ```
+   * {timestamp}.{payload}
+   * ```
+   *
+   * Where:
+   * - `timestamp` is the value from the `X-Webhook-Timestamp` header
+   * - `payload` is the raw JSON request body (exact bytes, not re-serialized)
+   *
+   * **Verification Steps:**
+   *
+   * 1. Extract the `X-Webhook-Timestamp` and `X-Webhook-Signature` headers
+   * 2. Get the raw request body bytes (do not parse and re-serialize)
+   * 3. Concatenate: `"{timestamp}.{payload}"`
+   * 4. Compute HMAC-SHA256 using your signing secret as the key
+   * 5. Hex-encode the result and compare with `X-Webhook-Signature`
+   * 6. Use constant-time comparison to prevent timing attacks
+   *
+   * **Example (Python):**
+   *
+   * ```python
+   * import hmac
+   * import hashlib
+   *
+   * def verify_webhook(signing_secret, payload, timestamp, signature):
+   *     message = f"{timestamp}.{payload.decode('utf-8')}"
+   *     expected = hmac.new(
+   *         signing_secret.encode('utf-8'),
+   *         message.encode('utf-8'),
+   *         hashlib.sha256
+   *     ).hexdigest()
+   *     return hmac.compare_digest(expected, signature)
+   * ```
+   *
+   * **Example (Node.js):**
+   *
+   * ```javascript
+   * const crypto = require('crypto');
+   *
+   * function verifyWebhook(signingSecret, payload, timestamp, signature) {
+   *   const message = `${timestamp}.${payload}`;
+   *   const expected = crypto
+   *     .createHmac('sha256', signingSecret)
+   *     .update(message)
+   *     .digest('hex');
+   *   return crypto.timingSafeEqual(
+   *     Buffer.from(expected),
+   *     Buffer.from(signature)
+   *   );
+   * }
+   * ```
+   *
+   * **Security Best Practices:**
+   *
+   * - Reject webhooks with timestamps older than 5 minutes to prevent replay attacks
+   * - Always use constant-time comparison for signature verification
+   * - Store your signing secret securely (e.g., environment variable, secrets manager)
+   * - Return a 2xx status code quickly, then process the webhook asynchronously
+   *
+   */
   webhookEvents: API.WebhookEvents = new API.WebhookEvents(this);
+  /**
+   * Webhook Subscriptions allow you to receive real-time notifications when events
+   * occur on your account.
+   *
+   * Configure webhook endpoints to receive events such as messages sent/received,
+   * delivery status changes, reactions, typing indicators, and more.
+   *
+   * Failed deliveries (5xx, 429, network errors) are retried up to 10 times over
+   * ~2 hours with exponential backoff. Each event includes a unique ID for
+   * deduplication.
+   *
+   * ## Webhook Headers
+   *
+   * Each webhook request includes the following headers:
+   *
+   * | Header | Description |
+   * |--------|-------------|
+   * | `X-Webhook-Event` | The event type (e.g., `message.sent`, `message.received`) |
+   * | `X-Webhook-Subscription-ID` | Your webhook subscription ID |
+   * | `X-Webhook-Timestamp` | Unix timestamp (seconds) when the webhook was sent |
+   * | `X-Webhook-Signature` | HMAC-SHA256 signature for verification |
+   *
+   * ## Verifying Webhook Signatures
+   *
+   * All webhooks are signed using HMAC-SHA256. You should always verify the signature
+   * to ensure the webhook originated from Linq and hasn't been tampered with.
+   *
+   * **Signature Construction:**
+   *
+   * The signature is computed over a concatenation of the timestamp and payload:
+   *
+   * ```
+   * {timestamp}.{payload}
+   * ```
+   *
+   * Where:
+   * - `timestamp` is the value from the `X-Webhook-Timestamp` header
+   * - `payload` is the raw JSON request body (exact bytes, not re-serialized)
+   *
+   * **Verification Steps:**
+   *
+   * 1. Extract the `X-Webhook-Timestamp` and `X-Webhook-Signature` headers
+   * 2. Get the raw request body bytes (do not parse and re-serialize)
+   * 3. Concatenate: `"{timestamp}.{payload}"`
+   * 4. Compute HMAC-SHA256 using your signing secret as the key
+   * 5. Hex-encode the result and compare with `X-Webhook-Signature`
+   * 6. Use constant-time comparison to prevent timing attacks
+   *
+   * **Example (Python):**
+   *
+   * ```python
+   * import hmac
+   * import hashlib
+   *
+   * def verify_webhook(signing_secret, payload, timestamp, signature):
+   *     message = f"{timestamp}.{payload.decode('utf-8')}"
+   *     expected = hmac.new(
+   *         signing_secret.encode('utf-8'),
+   *         message.encode('utf-8'),
+   *         hashlib.sha256
+   *     ).hexdigest()
+   *     return hmac.compare_digest(expected, signature)
+   * ```
+   *
+   * **Example (Node.js):**
+   *
+   * ```javascript
+   * const crypto = require('crypto');
+   *
+   * function verifyWebhook(signingSecret, payload, timestamp, signature) {
+   *   const message = `${timestamp}.${payload}`;
+   *   const expected = crypto
+   *     .createHmac('sha256', signingSecret)
+   *     .update(message)
+   *     .digest('hex');
+   *   return crypto.timingSafeEqual(
+   *     Buffer.from(expected),
+   *     Buffer.from(signature)
+   *   );
+   * }
+   * ```
+   *
+   * **Security Best Practices:**
+   *
+   * - Reject webhooks with timestamps older than 5 minutes to prevent replay attacks
+   * - Always use constant-time comparison for signature verification
+   * - Store your signing secret securely (e.g., environment variable, secrets manager)
+   * - Return a 2xx status code quickly, then process the webhook asynchronously
+   *
+   */
   webhookSubscriptions: API.WebhookSubscriptions = new API.WebhookSubscriptions(this);
+  /**
+   * Check whether a recipient address supports iMessage or RCS before sending a message.
+   *
+   */
   capability: API.Capability = new API.Capability(this);
+  webhooks: API.Webhooks = new API.Webhooks(this);
 }
 
 LinqAPIV3.Chats = Chats;
@@ -802,38 +1147,52 @@ LinqAPIV3.PhoneNumbers = PhoneNumbers;
 LinqAPIV3.WebhookEvents = WebhookEvents;
 LinqAPIV3.WebhookSubscriptions = WebhookSubscriptions;
 LinqAPIV3.Capability = Capability;
+LinqAPIV3.Webhooks = Webhooks;
 
 export declare namespace LinqAPIV3 {
   export type RequestOptions = Opts.RequestOptions;
 
+  export import ListChatsPagination = Pagination.ListChatsPagination;
+  export {
+    type ListChatsPaginationParams as ListChatsPaginationParams,
+    type ListChatsPaginationResponse as ListChatsPaginationResponse,
+  };
+
+  export import ListMessagesPagination = Pagination.ListMessagesPagination;
+  export {
+    type ListMessagesPaginationParams as ListMessagesPaginationParams,
+    type ListMessagesPaginationResponse as ListMessagesPaginationResponse,
+  };
+
   export {
     Chats as Chats,
     type Chat as Chat,
+    type MediaPart as MediaPart,
     type MessageContent as MessageContent,
+    type TextPart as TextPart,
     type ChatCreateResponse as ChatCreateResponse,
-    type ChatListResponse as ChatListResponse,
     type ChatSendVoicememoResponse as ChatSendVoicememoResponse,
+    type ChatsListChatsPagination as ChatsListChatsPagination,
     type ChatCreateParams as ChatCreateParams,
     type ChatUpdateParams as ChatUpdateParams,
-    type ChatListParams as ChatListParams,
+    type ChatListChatsParams as ChatListChatsParams,
     type ChatSendVoicememoParams as ChatSendVoicememoParams,
   };
 
   export {
     Messages as Messages,
     type ChatHandle as ChatHandle,
-    type MediaPart as MediaPart,
     type Message as Message,
     type MessageEffect as MessageEffect,
     type Reaction as Reaction,
     type ReactionType as ReactionType,
     type ReplyTo as ReplyTo,
-    type TextPart as TextPart,
     type MessageAddReactionResponse as MessageAddReactionResponse,
-    type MessageRetrieveThreadResponse as MessageRetrieveThreadResponse,
+    type MessagesListMessagesPagination as MessagesListMessagesPagination,
+    type MessageUpdateParams as MessageUpdateParams,
     type MessageDeleteParams as MessageDeleteParams,
     type MessageAddReactionParams as MessageAddReactionParams,
-    type MessageRetrieveThreadParams as MessageRetrieveThreadParams,
+    type MessageListMessagesThreadParams as MessageListMessagesThreadParams,
   };
 
   export {
@@ -865,11 +1224,58 @@ export declare namespace LinqAPIV3 {
 
   export {
     Capability as Capability,
-    type CapabilityCheckImessageResponse as CapabilityCheckImessageResponse,
-    type CapabilityCheckRcsResponse as CapabilityCheckRcsResponse,
-    type CapabilityCheckImessageParams as CapabilityCheckImessageParams,
-    type CapabilityCheckRcsParams as CapabilityCheckRcsParams,
+    type CapabilityCheckiMessageResponse as CapabilityCheckiMessageResponse,
+    type CapabilityCheckRCSResponse as CapabilityCheckRCSResponse,
+    type CapabilityCheckiMessageParams as CapabilityCheckiMessageParams,
+    type CapabilityCheckRCSParams as CapabilityCheckRCSParams,
+  };
+
+  export {
+    Webhooks as Webhooks,
+    type MessageEventV2 as MessageEventV2,
+    type MessagePayload as MessagePayload,
+    type ReactionEventBase as ReactionEventBase,
+    type SchemasMediaPartResponse as SchemasMediaPartResponse,
+    type SchemasMessageEffect as SchemasMessageEffect,
+    type SchemasTextPartResponse as SchemasTextPartResponse,
+    type MessageSentV2026WebhookEvent as MessageSentV2026WebhookEvent,
+    type MessageReceivedV2026WebhookEvent as MessageReceivedV2026WebhookEvent,
+    type MessageReadV2026WebhookEvent as MessageReadV2026WebhookEvent,
+    type MessageDeliveredV2026WebhookEvent as MessageDeliveredV2026WebhookEvent,
+    type MessageFailedV2026WebhookEvent as MessageFailedV2026WebhookEvent,
+    type ReactionAddedV2026WebhookEvent as ReactionAddedV2026WebhookEvent,
+    type ReactionRemovedV2026WebhookEvent as ReactionRemovedV2026WebhookEvent,
+    type ParticipantAddedV2026WebhookEvent as ParticipantAddedV2026WebhookEvent,
+    type ParticipantRemovedV2026WebhookEvent as ParticipantRemovedV2026WebhookEvent,
+    type ChatGroupNameUpdatedV2026WebhookEvent as ChatGroupNameUpdatedV2026WebhookEvent,
+    type ChatGroupIconUpdatedV2026WebhookEvent as ChatGroupIconUpdatedV2026WebhookEvent,
+    type ChatGroupNameUpdateFailedV2026WebhookEvent as ChatGroupNameUpdateFailedV2026WebhookEvent,
+    type ChatGroupIconUpdateFailedV2026WebhookEvent as ChatGroupIconUpdateFailedV2026WebhookEvent,
+    type ChatCreatedV2026WebhookEvent as ChatCreatedV2026WebhookEvent,
+    type ChatTypingIndicatorStartedV2026WebhookEvent as ChatTypingIndicatorStartedV2026WebhookEvent,
+    type ChatTypingIndicatorStoppedV2026WebhookEvent as ChatTypingIndicatorStoppedV2026WebhookEvent,
+    type PhoneNumberStatusUpdatedV2026WebhookEvent as PhoneNumberStatusUpdatedV2026WebhookEvent,
+    type MessageSentV2025WebhookEvent as MessageSentV2025WebhookEvent,
+    type MessageReceivedV2025WebhookEvent as MessageReceivedV2025WebhookEvent,
+    type MessageReadV2025WebhookEvent as MessageReadV2025WebhookEvent,
+    type MessageDeliveredV2025WebhookEvent as MessageDeliveredV2025WebhookEvent,
+    type MessageFailedV2025WebhookEvent as MessageFailedV2025WebhookEvent,
+    type ReactionAddedV2025WebhookEvent as ReactionAddedV2025WebhookEvent,
+    type ReactionRemovedV2025WebhookEvent as ReactionRemovedV2025WebhookEvent,
+    type ParticipantAddedV2025WebhookEvent as ParticipantAddedV2025WebhookEvent,
+    type ParticipantRemovedV2025WebhookEvent as ParticipantRemovedV2025WebhookEvent,
+    type ChatGroupNameUpdatedV2025WebhookEvent as ChatGroupNameUpdatedV2025WebhookEvent,
+    type ChatGroupIconUpdatedV2025WebhookEvent as ChatGroupIconUpdatedV2025WebhookEvent,
+    type ChatGroupNameUpdateFailedV2025WebhookEvent as ChatGroupNameUpdateFailedV2025WebhookEvent,
+    type ChatGroupIconUpdateFailedV2025WebhookEvent as ChatGroupIconUpdateFailedV2025WebhookEvent,
+    type ChatCreatedV2025WebhookEvent as ChatCreatedV2025WebhookEvent,
+    type ChatTypingIndicatorStartedV2025WebhookEvent as ChatTypingIndicatorStartedV2025WebhookEvent,
+    type ChatTypingIndicatorStoppedV2025WebhookEvent as ChatTypingIndicatorStoppedV2025WebhookEvent,
+    type PhoneNumberStatusUpdatedV2025WebhookEvent as PhoneNumberStatusUpdatedV2025WebhookEvent,
+    type EventsWebhookEvent as EventsWebhookEvent,
   };
 
+  export type MediaPartResponse = API.MediaPartResponse;
   export type ServiceType = API.ServiceType;
+  export type TextPartResponse = API.TextPartResponse;
 }