@linqapp/sdk 0.32.0 → 0.33.0

package/src/resources/experiences.ts

@@ -0,0 +1,118 @@
+// 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';
+import { path } from '../internal/utils/path';
+
+/**
+ * Let an agent pay on a customer's behalf with a single-use virtual card.
+ * Connect a customer once, then create a payment — a virtual card is minted
+ * scoped to that purchase and the card details are handed back for checkout.
+ */
+export class Experiences extends APIResource {
+  /**
+   * Get one experience
+   */
+  retrieve(experience: string, options?: RequestOptions): APIPromise<ExperienceRetrieveResponse> {
+    return this._client.get(path`/v3/experiences/${experience}`, options);
+  }
+
+  /**
+   * The experiences enabled for your account, with the actions you may invoke on
+   * each and the fields each action accepts. This is the authoritative list — an
+   * action missing here cannot be sent.
+   */
+  list(options?: RequestOptions): APIPromise<ExperienceListResponse> {
+    return this._client.get('/v3/experiences', options);
+  }
+}
+
+/**
+ * What an experience offers you. Deliberately a projection: where its templates
+ * live and how they are built is not yours to depend on, so it is not here.
+ */
+export interface ExperienceRetrieveResponse {
+  actions?: Array<ExperienceRetrieveResponse.Action>;
+
+  display_name?: string;
+
+  experience?: string;
+}
+
+export namespace ExperienceRetrieveResponse {
+  export interface Action {
+    /**
+     * Fields you may send in `params`, keyed by the exact name to use.
+     */
+    fields?: { [key: string]: Action.Fields };
+
+    name?: string;
+
+    summary?: string;
+  }
+
+  export namespace Action {
+    export interface Fields {
+      /**
+       * Maximum length, for strings.
+       */
+      max?: number;
+
+      required?: boolean;
+
+      type?: 'string' | 'cents' | 'int' | 'url';
+    }
+  }
+}
+
+export interface ExperienceListResponse {
+  experiences?: Array<ExperienceListResponse.Experience>;
+}
+
+export namespace ExperienceListResponse {
+  /**
+   * What an experience offers you. Deliberately a projection: where its templates
+   * live and how they are built is not yours to depend on, so it is not here.
+   */
+  export interface Experience {
+    actions?: Array<Experience.Action>;
+
+    display_name?: string;
+
+    experience?: string;
+  }
+
+  export namespace Experience {
+    export interface Action {
+      /**
+       * Fields you may send in `params`, keyed by the exact name to use.
+       */
+      fields?: { [key: string]: Action.Fields };
+
+      name?: string;
+
+      summary?: string;
+    }
+
+    export namespace Action {
+      export interface Fields {
+        /**
+         * Maximum length, for strings.
+         */
+        max?: number;
+
+        required?: boolean;
+
+        type?: 'string' | 'cents' | 'int' | 'url';
+      }
+    }
+  }
+}
+
+export declare namespace Experiences {
+  export {
+    type ExperienceRetrieveResponse as ExperienceRetrieveResponse,
+    type ExperienceListResponse as ExperienceListResponse,
+  };
+}

package/src/resources/index.ts

@@ -32,8 +32,8 @@ export {
   type ChatLeaveChatResponse,
   type ChatSendVoicememoResponse,
   type ChatCreateParams,
-  type ChatListChatsParams,
   type ChatUpdateParams,
+  type ChatListChatsParams,
   type ChatSendVoicememoParams,
   type ChatsListChatsPagination,
 } from './chats/chats';
@@ -41,10 +41,11 @@ export {
   ContactCard,
   type SetContactCard,
   type ContactCardRetrieveResponse,
-  type ContactCardRetrieveParams,
   type ContactCardCreateParams,
+  type ContactCardRetrieveParams,
   type ContactCardUpdateParams,
 } from './contact-card';
+export { Experiences, type ExperienceRetrieveResponse, type ExperienceListResponse } from './experiences';
 export {
   Messages,
   type Message,
@@ -54,12 +55,23 @@ export {
   type MessageAddReactionResponse,
   type MessageUpdateAppCardResponse,
   type MessageCreateParams,
-  type MessageListMessagesThreadParams,
-  type MessageAddReactionParams,
   type MessageUpdateParams,
+  type MessageAddReactionParams,
+  type MessageListMessagesThreadParams,
   type MessageUpdateAppCardParams,
   type MessagesListMessagesPagination,
 } from './messages';
+export {
+  PaymentHandles,
+  type PaymentHandleConnection,
+  type PaymentHandleVerifyParams,
+} from './payment-handles';
+export {
+  PaymentProviders,
+  type PaymentProvider,
+  type PaymentProviderConnectResponse,
+  type PaymentProviderConnectParams,
+} from './payment-providers';
 export {
   PaymentRequests,
   type PaymentRequest,
@@ -67,6 +79,12 @@ export {
   type PaymentRequestCreateParams,
   type PaymentRequestListParams,
 } from './payment-requests';
+export {
+  Payments,
+  type Payment,
+  type PaymentCredentialsResponse,
+  type PaymentCreateParams,
+} from './payments';
 export {
   PhoneNumbers,
   type PhoneNumberUpdateResponse,

package/src/resources/messages.ts

@@ -100,6 +100,15 @@ export class Messages extends APIResource {
    * Recipients (`to`) are an order-independent set: a single handle is a direct
    * chat, multiple handles a group chat.
    *
+   * ## Excluding lines
+   *
+   * `exclude_from` keeps specific lines out of **this** send's line pick. It only
+   * affects picking a line for a new chat — an existing chat is always reused on its
+   * own line, preferring a chat on a non-excluded line when the recipients have more
+   * than one. An exclusion never abandons a live chat or moves it to a new number,
+   * so if the only chat these recipients have is on an excluded line, that chat is
+   * still used. `from` tells you the line that was actually used.
+   *
    * ## Differences from POST /v3/chats
    *
    * - The first message **may contain a link** (including for a newly created chat).
@@ -144,52 +153,43 @@ export class Messages extends APIResource {
   }
 
   /**
-   * Retrieve all messages in a conversation thread. Given any message ID in the
-   * thread, returns the originator message and all replies in chronological order.
-   *
-   * If the message is not part of a thread, returns just that single message.
-   *
-   * Supports pagination and configurable ordering.
+   * Retrieve a specific message by its ID. This endpoint returns the full message
+   * details including text, attachments, reactions, and metadata.
    *
    * @example
    * ```ts
-   * // Automatically fetches more pages as needed.
-   * for await (const message of client.messages.listMessagesThread(
+   * const message = await client.messages.retrieve(
    *   '69a37c7d-af4f-4b5e-af42-e28e98ce873a',
-   * )) {
-   *   // ...
-   * }
+   * );
    * ```
    */
-  listMessagesThread(
-    messageID: string,
-    query: MessageListMessagesThreadParams | null | undefined = {},
-    options?: RequestOptions,
-  ): PagePromise<MessagesListMessagesPagination, Message> {
-    return this._client.getAPIList(path`/v3/messages/${messageID}/thread`, ListMessagesPagination<Message>, {
-      query,
-      ...options,
-    });
+  retrieve(messageID: string, options?: RequestOptions): APIPromise<Message> {
+    return this._client.get(path`/v3/messages/${messageID}`, options);
   }
 
   /**
-   * Retrieve a specific message by its ID. This endpoint returns the full message
-   * details including text, attachments, reactions, and metadata.
+   * Edit the text content of a specific part of a previously sent message.
+   *
+   * **Note:** A message can be edited up to 5 times, and only within 15 minutes of
+   * when it was originally sent.
    *
    * @example
    * ```ts
-   * const message = await client.messages.retrieve(
+   * const message = await client.messages.update(
    *   '69a37c7d-af4f-4b5e-af42-e28e98ce873a',
+   *   { text: 'This is the edited message content' },
    * );
    * ```
    */
-  retrieve(messageID: string, options?: RequestOptions): APIPromise<Message> {
-    return this._client.get(path`/v3/messages/${messageID}`, options);
+  update(messageID: string, body: MessageUpdateParams, options?: RequestOptions): APIPromise<Message> {
+    return this._client.patch(path`/v3/messages/${messageID}`, { body, ...options });
   }
 
   /**
    * Deletes a message from the Linq API only. This does NOT unsend or remove the
-   * message from the actual chat — recipients will still see the message.
+   * message from the actual chat — recipients will still see the message. Re-sending
+   * with a deleted message's idempotency key returns 404 — a deleted message is
+   * never resent.
    *
    * @example
    * ```ts
@@ -236,21 +236,32 @@ export class Messages extends APIResource {
   }
 
   /**
-   * Edit the text content of a specific part of a previously sent message.
+   * Retrieve all messages in a conversation thread. Given any message ID in the
+   * thread, returns the originator message and all replies in chronological order.
    *
-   * **Note:** A message can be edited up to 5 times, and only within 15 minutes of
-   * when it was originally sent.
+   * If the message is not part of a thread, returns just that single message.
+   *
+   * Supports pagination and configurable ordering.
    *
    * @example
    * ```ts
-   * const message = await client.messages.update(
+   * // Automatically fetches more pages as needed.
+   * for await (const message of client.messages.listMessagesThread(
    *   '69a37c7d-af4f-4b5e-af42-e28e98ce873a',
-   *   { text: 'This is the edited message content' },
-   * );
+   * )) {
+   *   // ...
+   * }
    * ```
    */
-  update(messageID: string, body: MessageUpdateParams, options?: RequestOptions): APIPromise<Message> {
-    return this._client.patch(path`/v3/messages/${messageID}`, { body, ...options });
+  listMessagesThread(
+    messageID: string,
+    query: MessageListMessagesThreadParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<MessagesListMessagesPagination, Message> {
+    return this._client.getAPIList(path`/v3/messages/${messageID}/thread`, ListMessagesPagination<Message>, {
+      query,
+      ...options,
+    });
   }
 
   /**
@@ -385,6 +396,16 @@ export interface Message {
    */
   read_at?: string | null;
 
+  /**
+   * Present only when this message was recovered by reconciliation rather than
+   * delivered live, and set to the time of that recovery. The field is omitted
+   * entirely for normally-delivered messages, which is the overwhelming majority.
+   * When present, expect `sent_at` to be substantially earlier — the message is
+   * genuine but was ingested late, so it may not have appeared in earlier reads of
+   * this conversation.
+   */
+  reconciled_at?: string;
+
   /**
    * Indicates this message is a threaded reply to another message
    */
@@ -702,6 +723,23 @@ export interface MessageCreateParams {
    */
   continuation_message?: MessageCreateParams.ContinuationMessage;
 
+  /**
+   * Body param: Lines (E.164) not to pick for this send. Applies for this request
+   * only — nothing is remembered between calls.
+   *
+   * **Exclusion only affects picking a line for a new chat.** If `to` already has a
+   * chat, that chat is reused on its own line, and a chat on a non-excluded line is
+   * preferred when there is more than one. If the only chat these recipients have is
+   * on an excluded line, it is still reused — an exclusion never abandons a live
+   * chat or moves it to a new number. Check `from` in the response to see the line
+   * that was actually used.
+   *
+   * Numbers that are not your lines are ignored. Every entry must be E.164 — a value
+   * like `4155551234` is rejected rather than silently skipped. Excluding every one
+   * of your available lines returns 400 when a line has to be picked.
+   */
+  exclude_from?: Array<string>;
+
   /**
    * Header param: Optional idempotency key for the send. Reuse the same key to
    * safely retry without sending twice. May also be supplied as
@@ -728,11 +766,16 @@ export namespace MessageCreateParams {
   }
 }
 
-export interface MessageListMessagesThreadParams extends ListMessagesPaginationParams {
+export interface MessageUpdateParams {
   /**
-   * Sort order for messages (asc = oldest first, desc = newest first)
+   * New text content for the message part
    */
-  order?: 'asc' | 'desc';
+  text: string;
+
+  /**
+   * Index of the message part to edit. Defaults to 0.
+   */
+  part_index?: number;
 }
 
 export interface MessageAddReactionParams {
@@ -761,16 +804,11 @@ export interface MessageAddReactionParams {
   part_index?: number;
 }
 
-export interface MessageUpdateParams {
-  /**
-   * New text content for the message part
-   */
-  text: string;
-
+export interface MessageListMessagesThreadParams extends ListMessagesPaginationParams {
   /**
-   * Index of the message part to edit. Defaults to 0.
+   * Sort order for messages (asc = oldest first, desc = newest first)
    */
-  part_index?: number;
+  order?: 'asc' | 'desc';
 }
 
 export interface MessageUpdateAppCardParams {
@@ -888,9 +926,9 @@ export declare namespace Messages {
     type MessageUpdateAppCardResponse as MessageUpdateAppCardResponse,
     type MessagesListMessagesPagination as MessagesListMessagesPagination,
     type MessageCreateParams as MessageCreateParams,
-    type MessageListMessagesThreadParams as MessageListMessagesThreadParams,
-    type MessageAddReactionParams as MessageAddReactionParams,
     type MessageUpdateParams as MessageUpdateParams,
+    type MessageAddReactionParams as MessageAddReactionParams,
+    type MessageListMessagesThreadParams as MessageListMessagesThreadParams,
     type MessageUpdateAppCardParams as MessageUpdateAppCardParams,
   };
 }

package/src/resources/payment-handles.ts

@@ -0,0 +1,114 @@
+// 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';
+import { path } from '../internal/utils/path';
+
+/**
+ * Let an agent pay on a customer's behalf with a single-use virtual card.
+ * Connect a customer once, then create a payment — a virtual card is minted
+ * scoped to that purchase and the card details are handed back for checkout.
+ */
+export class PaymentHandles extends APIResource {
+  /**
+   * Starts connecting a customer (by phone/email) so an agent can pay on their
+   * behalf. Linq drives the OTP + consent ceremony through the messaging channel;
+   * this returns `pending` and a `connection.created` webhook fires once the
+   * customer completes it.
+   *
+   * @example
+   * ```ts
+   * const paymentHandleConnection =
+   *   await client.paymentHandles.connect('handle');
+   * ```
+   */
+  connect(handle: string, options?: RequestOptions): APIPromise<PaymentHandleConnection> {
+    return this._client.post(path`/v3/payments/handles/${handle}/connect`, options);
+  }
+
+  /**
+   * Get a handle's connection status
+   *
+   * @example
+   * ```ts
+   * const paymentHandleConnection =
+   *   await client.paymentHandles.connection('handle');
+   * ```
+   */
+  connection(handle: string, options?: RequestOptions): APIPromise<PaymentHandleConnection> {
+    return this._client.get(path`/v3/payments/handles/${handle}/connection`, options);
+  }
+
+  /**
+   * Revokes this partner's grant for the customer. Only your grant is removed; the
+   * customer's wallet at the provider is untouched.
+   *
+   * @example
+   * ```ts
+   * const paymentHandleConnection =
+   *   await client.paymentHandles.revoke('handle');
+   * ```
+   */
+  revoke(handle: string, options?: RequestOptions): APIPromise<PaymentHandleConnection> {
+    return this._client.delete(path`/v3/payments/handles/${handle}/connection`, options);
+  }
+
+  /**
+   * Completes the ceremony `connect` started: verifies the code, records the
+   * customer's consent, and stores the connection. Returns `connected` on success,
+   * after which payments for this handle no longer need the customer present.
+   *
+   * The code reaches you however your channel works — typically the customer replies
+   * with it in the thread. Codes are single-use and short-lived; if one has expired,
+   * call `connect` again for a fresh `connect_id`.
+   *
+   * @example
+   * ```ts
+   * const paymentHandleConnection =
+   *   await client.paymentHandles.verify('handle', {
+   *     code: '482913',
+   *     connect_id: 'cs_01HZY8',
+   *   });
+   * ```
+   */
+  verify(
+    handle: string,
+    body: PaymentHandleVerifyParams,
+    options?: RequestOptions,
+  ): APIPromise<PaymentHandleConnection> {
+    return this._client.post(path`/v3/payments/handles/${handle}/verify`, { body, ...options });
+  }
+}
+
+export interface PaymentHandleConnection {
+  /**
+   * Returned only by `connect`, and only while the ceremony is pending. Nothing on
+   * our side persists it — it comes back from the provider and is required again to
+   * verify — so hold it until you submit the code.
+   */
+  connect_id?: string;
+
+  handle?: string;
+
+  status?: 'not_connected' | 'pending' | 'connected' | 'revoked';
+}
+
+export interface PaymentHandleVerifyParams {
+  /**
+   * The one-time code the customer received.
+   */
+  code: string;
+
+  /**
+   * The id returned by `connect`.
+   */
+  connect_id: string;
+}
+
+export declare namespace PaymentHandles {
+  export {
+    type PaymentHandleConnection as PaymentHandleConnection,
+    type PaymentHandleVerifyParams as PaymentHandleVerifyParams,
+  };
+}

package/src/resources/payment-providers.ts

@@ -0,0 +1,81 @@
+// 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';
+import { path } from '../internal/utils/path';
+
+/**
+ * Let an agent pay on a customer's behalf with a single-use virtual card.
+ * Connect a customer once, then create a payment — a virtual card is minted
+ * scoped to that purchase and the card details are handed back for checkout.
+ */
+export class PaymentProviders extends APIResource {
+  /**
+   * Returns your organization's onboarding status for a payment provider.
+   *
+   * @example
+   * ```ts
+   * const paymentProvider =
+   *   await client.paymentProviders.retrieve('provider');
+   * ```
+   */
+  retrieve(provider: string, options?: RequestOptions): APIPromise<PaymentProvider> {
+    return this._client.get(path`/v3/payments/providers/${provider}`, options);
+  }
+
+  /**
+   * Begins connecting your organization to a payment provider (e.g. `agentcard`).
+   * Returns a hosted URL where an admin authorizes the connection; on completion the
+   * provider redirects back and Linq stores your connected credentials.
+   *
+   * @example
+   * ```ts
+   * const response = await client.paymentProviders.connect(
+   *   'provider',
+   *   {
+   *     return_url: 'https://partner.example/settings/payments',
+   *   },
+   * );
+   * ```
+   */
+  connect(
+    provider: string,
+    body: PaymentProviderConnectParams,
+    options?: RequestOptions,
+  ): APIPromise<PaymentProviderConnectResponse> {
+    return this._client.post(path`/v3/payments/providers/${provider}/connect`, { body, ...options });
+  }
+}
+
+export interface PaymentProvider {
+  provider?: string;
+
+  status?: 'onboarding' | 'ready' | 'disabled';
+}
+
+export interface PaymentProviderConnectResponse {
+  /**
+   * Send the admin here to authorize the connection.
+   */
+  hosted_url?: string;
+
+  session_id?: string;
+
+  status?: string;
+}
+
+export interface PaymentProviderConnectParams {
+  /**
+   * Where to send the admin after they authorize the connection.
+   */
+  return_url: string;
+}
+
+export declare namespace PaymentProviders {
+  export {
+    type PaymentProvider as PaymentProvider,
+    type PaymentProviderConnectResponse as PaymentProviderConnectResponse,
+    type PaymentProviderConnectParams as PaymentProviderConnectParams,
+  };
+}

package/src/resources/payment-requests.ts

@@ -25,7 +25,7 @@ import { path } from '../internal/utils/path';
  *
  * ## Connected accounts (Stripe Standard, direct charges)
  *
- * Agent Pay runs on **Stripe Connect Standard accounts** using **direct
+ * Payments run on **Stripe Connect Standard accounts** using **direct
  * charges**: the charge is created on *your* connected account and **you are
  * the merchant of record**. That means the money, the payout schedule, the
  * customer relationship, and the compliance surface are all yours — Linq
@@ -108,7 +108,7 @@ import { path } from '../internal/utils/path';
  * no-install checkout sheet. Everywhere else (Android, desktop, iPhones
  * without the App Clip yet) the same URL opens the web checkout, so the link
  * always works. The App Clip experience for your payment links is registered
- * automatically by Linq and refreshed whenever you update your Agent Pay
+ * automatically by Linq and refreshed whenever you update your payments
  * branding; a newly registered experience can take up to ~24 hours to
  * activate on Apple's side, during which links open the web checkout.
  *