@linqapp/sdk 0.28.0 → 0.28.2

package/src/internal/qs/types.ts

@@ -0,0 +1,71 @@
+export type Format = 'RFC1738' | 'RFC3986';
+
+export type DefaultEncoder = (str: any, defaultEncoder?: any, charset?: string) => string;
+export type DefaultDecoder = (str: string, decoder?: any, charset?: string) => string;
+
+export type BooleanOptional = boolean | undefined;
+
+export type StringifyBaseOptions = {
+  delimiter?: string;
+  allowDots?: boolean;
+  encodeDotInKeys?: boolean;
+  strictNullHandling?: boolean;
+  skipNulls?: boolean;
+  encode?: boolean;
+  encoder?: (
+    str: any,
+    defaultEncoder: DefaultEncoder,
+    charset: string,
+    type: 'key' | 'value',
+    format?: Format,
+  ) => string;
+  filter?: Array<PropertyKey> | ((prefix: PropertyKey, value: any) => any);
+  arrayFormat?: 'indices' | 'brackets' | 'repeat' | 'comma';
+  indices?: boolean;
+  sort?: ((a: PropertyKey, b: PropertyKey) => number) | null;
+  serializeDate?: (d: Date) => string;
+  format?: 'RFC1738' | 'RFC3986';
+  formatter?: (str: PropertyKey) => string;
+  encodeValuesOnly?: boolean;
+  addQueryPrefix?: boolean;
+  charset?: 'utf-8' | 'iso-8859-1';
+  charsetSentinel?: boolean;
+  allowEmptyArrays?: boolean;
+  commaRoundTrip?: boolean;
+};
+
+export type StringifyOptions = StringifyBaseOptions;
+
+export type ParseBaseOptions = {
+  comma?: boolean;
+  delimiter?: string | RegExp;
+  depth?: number | false;
+  decoder?: (str: string, defaultDecoder: DefaultDecoder, charset: string, type: 'key' | 'value') => any;
+  arrayLimit?: number;
+  parseArrays?: boolean;
+  plainObjects?: boolean;
+  allowPrototypes?: boolean;
+  allowSparse?: boolean;
+  parameterLimit?: number;
+  strictDepth?: boolean;
+  strictNullHandling?: boolean;
+  ignoreQueryPrefix?: boolean;
+  charset?: 'utf-8' | 'iso-8859-1';
+  charsetSentinel?: boolean;
+  interpretNumericEntities?: boolean;
+  allowEmptyArrays?: boolean;
+  duplicates?: 'combine' | 'first' | 'last';
+  allowDots?: boolean;
+  decodeDotInKeys?: boolean;
+};
+
+export type ParseOptions = ParseBaseOptions;
+
+export type ParsedQs = {
+  [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[];
+};
+
+// Type to remove null or undefined union from each property
+export type NonNullableProperties<T> = {
+  [K in keyof T]-?: Exclude<T[K], undefined | null>;
+};

package/src/internal/qs/utils.ts

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
+
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
+
+const hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (isArray(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (isArray(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (isArray(target) && !isArray(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (isArray(target) && isArray(source)) {
+    source.forEach(function (item, i) {
+      if (has(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

package/src/internal/utils/query.ts

@@ -1,23 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { LinqAPIV3Error } from '../../core/error';
+import * as qs from '../qs/stringify';
 
-/**
- * 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('&');
+  return qs.stringify(query, { arrayFormat: 'comma' });
 }

package/src/resources/attachments.ts

@@ -170,7 +170,7 @@ import { path } from '../internal/utils/path';
  * |---|---|---|
  * | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
  * | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
- * | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+ * | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
  * | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
  *
  * **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).

package/src/resources/available-number.ts

@@ -0,0 +1,72 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+
+/**
+ * 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.
+ */
+export class AvailableNumber extends APIResource {
+  /**
+   * Returns the best available line (E.164) to send from, applying smart number
+   * assignment. Optionally pass `to` recipients to make the choice "sticky" —
+   * reusing the line an existing chat with those recipients is already on. Without
+   * `to`, the best healthy line is chosen.
+   *
+   * This is advisory: it does not reserve the line or change selection state. Pass
+   * the returned `phone_number` as `from` when you create the chat to guarantee the
+   * same line.
+   *
+   * Also returns `vcf_url`: a time-limited link to a vCard (`.vcf`) for the chosen
+   * line, carrying its contact card (name/photo) with the chosen number as the
+   * primary `TEL` and the partner's other healthy lines as backups. Share it with
+   * recipients so they can save the line as a contact.
+   */
+  retrieve(
+    query: AvailableNumberRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<AvailableNumberRetrieveResponse> {
+    return this._client.get('/v3/available_number', { query, ...options });
+  }
+}
+
+/**
+ * The line smart number assignment selected, plus a shareable vCard.
+ */
+export interface AvailableNumberRetrieveResponse {
+  /**
+   * The selected sending line in E.164 format.
+   */
+  phone_number: string;
+
+  /**
+   * Time-limited link to a vCard (`.vcf`) for the selected line. The card carries
+   * the line's contact details with the selected number as the primary `TEL` and the
+   * partner's other healthy lines as backups. The link expires; re-call this
+   * endpoint to mint a fresh one.
+   */
+  vcf_url: string;
+}
+
+export interface AvailableNumberRetrieveParams {
+  /**
+   * Recipient handles (E.164 or email) the message is destined for. When provided,
+   * an existing chat with these recipients makes the choice sticky. Repeat the
+   * parameter for multiple recipients.
+   */
+  to?: Array<string>;
+}
+
+export declare namespace AvailableNumber {
+  export {
+    type AvailableNumberRetrieveResponse as AvailableNumberRetrieveResponse,
+    type AvailableNumberRetrieveParams as AvailableNumberRetrieveParams,
+  };
+}

package/src/resources/chats/chats.ts

@@ -523,9 +523,19 @@ export namespace MessageContent {
 
     /**
      * Visible layout of the card. At least one of `caption`, `subcaption`,
-     * `trailing_caption`, or `trailing_subcaption` must be set, otherwise the card
-     * renders as an empty bubble. Any image on the card is drawn by the recipient's
-     * installed app extension; it cannot be supplied here.
+     * `trailing_caption`, `trailing_subcaption`, or `image_url` must be set, otherwise
+     * the card renders as an empty bubble.
+     *
+     * `image_url` displays a preview image at the top of the card. The image renders
+     * on the recipient's card whether or not they have your app installed. The small
+     * icon beside the caption is the app's own icon and is not settable here.
+     *
+     * `* Note - requires a trusted chat w/ inbound activity`
+     *
+     * `image_title` and `image_subtitle` render as text overlaid on the image (title
+     * bold, subtitle beneath it). They only appear when `image_url` is set — without
+     * an image there is nothing to overlay — so setting either without `image_url` is
+     * rejected.
      */
     layout: IMessageAppPart.Layout;
 
@@ -534,17 +544,28 @@ export namespace MessageContent {
      */
     type: 'imessage_app';
 
-    /**
-     * Absolute HTTPS URL delivered to the recipient's installed iMessage app when they
-     * tap the card. Opaque to Messages.
-     */
-    url: string;
-
     /**
      * Text shown on surfaces that cannot render the card (notifications, lock screen).
      * Defaults to the caption when omitted.
      */
     fallback_text?: string;
+
+    /**
+     * Whether the card renders as your app's interactive balloon for recipients who
+     * have your iMessage app installed. `true` (default) lets your installed extension
+     * draw its live, interactive view for those recipients; everyone else sees the
+     * static card built from `layout`. `false` always shows the static `layout` card,
+     * even to recipients who have the app installed. Recipients without your app
+     * always see the static card regardless of this flag.
+     */
+    interactive?: boolean;
+
+    /**
+     * URL the recipient's app opens when they tap the card. Either an absolute
+     * `https://` URL (capped at 2048 characters) or a `data:` URL carrying inline app
+     * state, e.g. a game's encoded state (capped at 16384 characters).
+     */
+    url?: string;
   }
 
   export namespace IMessageAppPart {
@@ -576,9 +597,19 @@ export namespace MessageContent {
 
     /**
      * Visible layout of the card. At least one of `caption`, `subcaption`,
-     * `trailing_caption`, or `trailing_subcaption` must be set, otherwise the card
-     * renders as an empty bubble. Any image on the card is drawn by the recipient's
-     * installed app extension; it cannot be supplied here.
+     * `trailing_caption`, `trailing_subcaption`, or `image_url` must be set, otherwise
+     * the card renders as an empty bubble.
+     *
+     * `image_url` displays a preview image at the top of the card. The image renders
+     * on the recipient's card whether or not they have your app installed. The small
+     * icon beside the caption is the app's own icon and is not settable here.
+     *
+     * `* Note - requires a trusted chat w/ inbound activity`
+     *
+     * `image_title` and `image_subtitle` render as text overlaid on the image (title
+     * bold, subtitle beneath it). They only appear when `image_url` is set — without
+     * an image there is nothing to overlay — so setting either without `image_url` is
+     * rejected.
      */
     export interface Layout {
       /**
@@ -586,6 +617,27 @@ export namespace MessageContent {
        */
       caption?: string;
 
+      /**
+       * Text shown below `image_title`, overlaid on the card image. Requires
+       * `image_url`.
+       */
+      image_subtitle?: string;
+
+      /**
+       * Bold text overlaid on the card image. Requires `image_url` (rejected without
+       * it).
+       */
+      image_title?: string;
+
+      /**
+       * URL of an image (JPEG, PNG, HEIF, or WebP) to display as the card's preview
+       * image; an unreachable or non-image URL returns a validation error. Renders for
+       * all recipients regardless of whether they have the app. Note - requires a
+       * trusted chat w/ inbound activity. In responses, this is the re-hosted
+       * `cdn.linqapp.com` copy of the image you supplied, not your original URL.
+       */
+      image_url?: string;
+
       /**
        * Secondary label, below `caption` on the left.
        */

package/src/resources/chats/location.ts

@@ -40,16 +40,17 @@ export class Location extends APIResource {
   /**
    * Retrieve the current location for contacts sharing with you in a chat.
    *
-   * Returns a [GeoJSON](https://datatracker.ietf.org/doc/html/rfc7946)
-   * `FeatureCollection` with a `Feature` for each participant actively sharing their
-   * location.
+   * The response is wrapped in the standard `{ "success": true, "data": ... }`
+   * envelope — the body is **not** a bare GeoJSON document. `data` is a
+   * [GeoJSON](https://datatracker.ietf.org/doc/html/rfc7946) `FeatureCollection`
+   * with a `Feature` for each participant actively sharing their location.
    *
-   * Works for both 1:1 and group chats. In group chats, returns a separate feature
-   * for each participant who is sharing. Each feature's `properties.handle`
-   * identifies the user.
+   * Works for both 1:1 and group chats. In group chats, `data.features` contains a
+   * separate feature for each participant who is sharing. Each feature's
+   * `properties.handle` identifies the user.
    *
-   * Returns an empty `features` array if no one is sharing or no location data is
-   * available yet.
+   * Returns an empty `data.features` array if no one is sharing or no location data
+   * is available yet.
    *
    * @example
    * ```ts