@linqapp/sdk 0.1.5 → 0.4.0

package/src/core/pagination.ts

@@ -0,0 +1,212 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { LinqAPIV3Error } from './error';
+import { FinalRequestOptions } from '../internal/request-options';
+import { defaultParseResponse } from '../internal/parse';
+import { type LinqAPIV3 } from '../client';
+import { APIPromise } from './api-promise';
+import { type APIResponseProps } from '../internal/parse';
+import { maybeObj } from '../internal/utils/values';
+
+export type PageRequestOptions = Pick<FinalRequestOptions, 'query' | 'headers' | 'body' | 'path' | 'method'>;
+
+export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
+  #client: LinqAPIV3;
+  protected options: FinalRequestOptions;
+
+  protected response: Response;
+  protected body: unknown;
+
+  constructor(client: LinqAPIV3, response: Response, body: unknown, options: FinalRequestOptions) {
+    this.#client = client;
+    this.options = options;
+    this.response = response;
+    this.body = body;
+  }
+
+  abstract nextPageRequestOptions(): PageRequestOptions | null;
+
+  abstract getPaginatedItems(): Item[];
+
+  hasNextPage(): boolean {
+    const items = this.getPaginatedItems();
+    if (!items.length) return false;
+    return this.nextPageRequestOptions() != null;
+  }
+
+  async getNextPage(): Promise<this> {
+    const nextOptions = this.nextPageRequestOptions();
+    if (!nextOptions) {
+      throw new LinqAPIV3Error(
+        'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
+      );
+    }
+
+    return await this.#client.requestAPIList(this.constructor as any, nextOptions);
+  }
+
+  async *iterPages(): AsyncGenerator<this> {
+    let page: this = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+}
+
+/**
+ * This subclass of Promise will resolve to an instantiated Page once the request completes.
+ *
+ * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg:
+ *
+ *    for await (const item of client.items.list()) {
+ *      console.log(item)
+ *    }
+ */
+export class PagePromise<
+    PageClass extends AbstractPage<Item>,
+    Item = ReturnType<PageClass['getPaginatedItems']>[number],
+  >
+  extends APIPromise<PageClass>
+  implements AsyncIterable<Item>
+{
+  constructor(
+    client: LinqAPIV3,
+    request: Promise<APIResponseProps>,
+    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
+  ) {
+    super(
+      client,
+      request,
+      async (client, props) =>
+        new Page(client, props.response, await defaultParseResponse(client, props), props.options),
+    );
+  }
+
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+}
+
+export interface ListChatsPaginationResponse<Item> {
+  chats: Array<Item>;
+
+  next_cursor: string;
+}
+
+export interface ListChatsPaginationParams {
+  cursor?: string;
+
+  limit?: number;
+}
+
+export class ListChatsPagination<Item>
+  extends AbstractPage<Item>
+  implements ListChatsPaginationResponse<Item>
+{
+  chats: Array<Item>;
+
+  next_cursor: string;
+
+  constructor(
+    client: LinqAPIV3,
+    response: Response,
+    body: ListChatsPaginationResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.chats = body.chats || [];
+    this.next_cursor = body.next_cursor || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.chats ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.next_cursor;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        cursor,
+      },
+    };
+  }
+}
+
+export interface ListMessagesPaginationResponse<Item> {
+  messages: Array<Item>;
+
+  next_cursor: string;
+}
+
+export interface ListMessagesPaginationParams {
+  cursor?: string;
+
+  limit?: number;
+}
+
+export class ListMessagesPagination<Item>
+  extends AbstractPage<Item>
+  implements ListMessagesPaginationResponse<Item>
+{
+  messages: Array<Item>;
+
+  next_cursor: string;
+
+  constructor(
+    client: LinqAPIV3,
+    response: Response,
+    body: ListMessagesPaginationResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.messages = body.messages || [];
+    this.next_cursor = body.next_cursor || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.messages ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.next_cursor;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        cursor,
+      },
+    };
+  }
+}

package/src/index.ts

@@ -5,6 +5,7 @@ export { LinqAPIV3 as default } from './client';
 export { type Uploadable, toFile } from './core/uploads';
 export { APIPromise } from './core/api-promise';
 export { LinqAPIV3, type ClientOptions } from './client';
+export { PagePromise } from './core/pagination';
 export {
   LinqAPIV3Error,
   APIError,

package/src/internal/utils/query.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { LinqAPIV3Error } from '../../core/error';
+
+/**
+ * Basic re-implementation of `qs.stringify` for primitive types.
+ */
+export function stringifyQuery(query: object | Record<string, unknown>) {
+  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 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('&');
+}

package/src/internal/utils.ts

@@ -6,3 +6,4 @@ export * from './utils/env';
 export * from './utils/log';
 export * from './utils/uuid';
 export * from './utils/sleep';
+export * from './utils/query';

package/src/pagination.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';

package/src/resources/attachments.ts

@@ -5,6 +5,70 @@ import { APIPromise } from '../core/api-promise';
 import { RequestOptions } from '../internal/request-options';
 import { path } from '../internal/utils/path';
 
+/**
+ * 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
+ */
 export class Attachments extends APIResource {
   /**
    * **This endpoint is optional.** You can send media by simply providing a URL in

package/src/resources/capability.ts

@@ -4,6 +4,9 @@ import { APIResource } from '../core/resource';
 import { APIPromise } from '../core/api-promise';
 import { RequestOptions } from '../internal/request-options';
 
+/**
+ * Check whether a recipient address supports iMessage or RCS before sending a message.
+ */
 export class Capability extends APIResource {
   /**
    * Check whether a recipient address (phone number or email) is reachable via
@@ -11,15 +14,15 @@ export class Capability extends APIResource {
    *
    * @example
    * ```ts
-   * const response = await client.capability.checkImessage({
+   * const response = await client.capability.checkiMessage({
    *   address: '+15551234567',
    * });
    * ```
    */
-  checkImessage(
-    body: CapabilityCheckImessageParams,
+  checkiMessage(
+    body: CapabilityCheckiMessageParams,
     options?: RequestOptions,
-  ): APIPromise<CapabilityCheckImessageResponse> {
+  ): APIPromise<CapabilityCheckiMessageResponse> {
     return this._client.post('/v3/capability/check_imessage', { body, ...options });
   }
 
@@ -28,17 +31,17 @@ export class Capability extends APIResource {
    *
    * @example
    * ```ts
-   * const response = await client.capability.checkRcs({
+   * const response = await client.capability.checkRCS({
    *   address: '+15551234567',
    * });
    * ```
    */
-  checkRcs(body: CapabilityCheckRcsParams, options?: RequestOptions): APIPromise<CapabilityCheckRcsResponse> {
+  checkRCS(body: CapabilityCheckRCSParams, options?: RequestOptions): APIPromise<CapabilityCheckRCSResponse> {
     return this._client.post('/v3/capability/check_rcs', { body, ...options });
   }
 }
 
-export interface CapabilityCheckImessageResponse {
+export interface CapabilityCheckiMessageResponse {
   /**
    * The recipient address that was checked
    */
@@ -50,7 +53,7 @@ export interface CapabilityCheckImessageResponse {
   available: boolean;
 }
 
-export interface CapabilityCheckRcsResponse {
+export interface CapabilityCheckRCSResponse {
   /**
    * The recipient address that was checked
    */
@@ -62,7 +65,7 @@ export interface CapabilityCheckRcsResponse {
   available: boolean;
 }
 
-export interface CapabilityCheckImessageParams {
+export interface CapabilityCheckiMessageParams {
   /**
    * The recipient phone number or email address to check
    */
@@ -75,7 +78,7 @@ export interface CapabilityCheckImessageParams {
   from?: string;
 }
 
-export interface CapabilityCheckRcsParams {
+export interface CapabilityCheckRCSParams {
   /**
    * The recipient phone number or email address to check
    */
@@ -90,9 +93,9 @@ export interface CapabilityCheckRcsParams {
 
 export declare namespace Capability {
   export {
-    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,
   };
 }