increase 0.8.0 → 0.9.0

package/src/core.ts

@@ -9,6 +9,7 @@ import {
   type RequestInit,
   type Response,
 } from './_shims/fetch.js';
+export { type Response };
 import { isMultipartBody } from './uploads';
 export {
   maybeMultipartFormRequestOptions,
@@ -21,6 +22,100 @@ const MAX_RETRIES = 2;
 
 export type Fetch = (url: RequestInfo, init?: RequestInit) => Promise<Response>;
 
+type PromiseOrValue<T> = T | Promise<T>;
+
+type APIResponseProps = {
+  response: Response;
+  options: FinalRequestOptions;
+  controller: AbortController;
+};
+
+async function defaultParseResponse<T>(props: APIResponseProps): Promise<T> {
+  const { response } = props;
+  const contentType = response.headers.get('content-type');
+  if (contentType?.includes('application/json')) {
+    const json = await response.json();
+
+    debug('response', response.status, response.url, response.headers, json);
+
+    return json as T;
+  }
+
+  // TODO handle blob, arraybuffer, other content types, etc.
+  const text = await response.text();
+  debug('response', response.status, response.url, response.headers, text);
+  return text as T;
+}
+
+/**
+ * A subclass of `Promise` providing additional helper methods
+ * for interacting with the SDK.
+ */
+export class APIPromise<T> extends Promise<T> {
+  private parsedPromise: Promise<T> | undefined;
+
+  constructor(
+    private responsePromise: Promise<APIResponseProps>,
+    private parseResponse: (props: APIResponseProps) => PromiseOrValue<T> = defaultParseResponse,
+  ) {
+    super((resolve) => {
+      // this is maybe a bit weird but this has to be a no-op to not implicitly
+      // parse the response body; instead .then, .catch, .finally are overridden
+      // to parse the response
+      resolve(null as any);
+    });
+  }
+
+  _thenUnwrap<U>(transform: (data: T) => U): APIPromise<U> {
+    return new APIPromise(this.responsePromise, async (props) => transform(await this.parseResponse(props)));
+  }
+
+  /**
+   * Gets the raw `Response` instance instead of parsing the response
+   * data.
+   *
+   * If you want to parse the response body but still get the `Response`
+   * instance, you can use {@link withResponse()}.
+   */
+  asResponse(): Promise<Response> {
+    return this.responsePromise.then((p) => p.response);
+  }
+  /**
+   * Gets the parsed response data and the raw `Response` instance.
+   *
+   * If you just want to get the raw `Response` instance without parsing it,
+   * you can use {@link asResponse()}.
+   */
+  async withResponse(): Promise<{ data: T; response: Response }> {
+    const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+    return { data, response };
+  }
+
+  private parse(): Promise<T> {
+    if (!this.parsedPromise) {
+      this.parsedPromise = this.responsePromise.then(this.parseResponse);
+    }
+    return this.parsedPromise;
+  }
+
+  override then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+
+  override catch<TResult = never>(
+    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null,
+  ): Promise<T | TResult> {
+    return this.parse().catch(onrejected);
+  }
+
+  override finally(onfinally?: (() => void) | undefined | null): Promise<T> {
+    return this.parse().finally(onfinally);
+  }
+}
+
 export abstract class APIClient {
   baseURL: string;
   maxRetries: number;
@@ -84,27 +179,39 @@ export abstract class APIClient {
     return `stainless-node-retry-${uuid4()}`;
   }
 
-  get<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp> {
-    return this.request({ method: 'get', path, ...opts });
+  get<Req extends {}, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
+    return this.methodRequest('get', path, opts);
   }
-  post<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp> {
-    return this.request({ method: 'post', path, ...opts });
+
+  post<Req extends {}, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
+    return this.methodRequest('post', path, opts);
   }
-  patch<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp> {
-    return this.request({ method: 'patch', path, ...opts });
+
+  patch<Req extends {}, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
+    return this.methodRequest('patch', path, opts);
   }
-  put<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp> {
-    return this.request({ method: 'put', path, ...opts });
+
+  put<Req extends {}, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
+    return this.methodRequest('put', path, opts);
   }
-  delete<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp> {
-    return this.request({ method: 'delete', path, ...opts });
+
+  delete<Req extends {}, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
+    return this.methodRequest('delete', path, opts);
+  }
+
+  private methodRequest<Req extends {}, Rsp>(
+    method: HTTPMethod,
+    path: string,
+    opts?: PromiseOrValue<RequestOptions<Req>>,
+  ): APIPromise<Rsp> {
+    return this.request(Promise.resolve(opts).then((opts) => ({ method, path, ...opts })));
   }
 
   getAPIList<Item, PageClass extends AbstractPage<Item> = AbstractPage<Item>>(
     path: string,
     Page: new (...args: any[]) => PageClass,
     opts?: RequestOptions<any>,
-  ): PagePromise<PageClass> {
+  ): PagePromise<PageClass, Item> {
     return this.requestAPIList(Page, { method: 'get', path, ...opts });
   }
 
@@ -198,14 +305,27 @@ export abstract class APIClient {
     return APIError.generate(status, error, message, headers);
   }
 
-  async request<Req extends {}, Rsp>(
-    options: FinalRequestOptions<Req>,
-    retriesRemaining = options.maxRetries ?? this.maxRetries,
-  ): Promise<APIResponse<Rsp>> {
+  request<Req extends {}, Rsp>(
+    options: PromiseOrValue<FinalRequestOptions<Req>>,
+    remainingRetries: number | null = null,
+  ): APIPromise<Rsp> {
+    return new APIPromise(this.makeRequest(options, remainingRetries));
+  }
+
+  private async makeRequest<T>(
+    optionsInput: PromiseOrValue<FinalRequestOptions>,
+    retriesRemaining: number | null,
+  ): Promise<{ response: Response; options: FinalRequestOptions; controller: AbortController }> {
+    const options = await optionsInput;
+    if (retriesRemaining == null) {
+      retriesRemaining = options.maxRetries ?? this.maxRetries;
+    }
+
     const { req, url, timeout } = this.buildRequest(options);
+
     await this.prepareRequest(req, { url });
 
-    this.debug('request', url, options, req.headers);
+    debug('request', url, options, req.headers);
 
     if (options.signal?.aborted) {
       throw new APIUserAbortError();
@@ -238,42 +358,21 @@ export abstract class APIClient {
       const errJSON = safeJSON(errText);
       const errMessage = errJSON ? undefined : errText;
 
-      this.debug('response', response.status, url, responseHeaders, errMessage);
+      debug('response', response.status, url, responseHeaders, errMessage);
 
       const err = this.makeStatusError(response.status, errJSON, errMessage, responseHeaders);
       throw err;
     }
 
-    const contentType = response.headers.get('content-type');
-    if (contentType?.includes('application/json')) {
-      const json = await response.json();
-
-      if (typeof json === 'object' && json != null) {
-        /** @deprecated – we expect to change this interface in the near future. */
-        Object.defineProperty(json, 'responseHeaders', {
-          enumerable: false,
-          writable: false,
-          value: responseHeaders,
-        });
-      }
-
-      this.debug('response', response.status, url, responseHeaders, json);
-
-      return json as APIResponse<Rsp>;
-    }
-
-    // TODO handle blob, arraybuffer, other content types, etc.
-    const text = response.text();
-    this.debug('response', response.status, url, responseHeaders, text);
-    return text as Promise<any>;
+    return { response, options, controller };
   }
 
   requestAPIList<Item = unknown, PageClass extends AbstractPage<Item> = AbstractPage<Item>>(
     Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
     options: FinalRequestOptions,
-  ): PagePromise<PageClass> {
-    const requestPromise = this.request(options) as Promise<APIResponse<unknown>>;
-    return new PagePromise(this, requestPromise, options, Page);
+  ): PagePromise<PageClass, Item> {
+    const request = this.makeRequest(options, null);
+    return new PagePromise<PageClass, Item>(this, request, Page);
   }
 
   buildURL<Req>(path: string, query: Req | undefined): string {
@@ -401,12 +500,6 @@ export abstract class APIClient {
   private getUserAgent(): string {
     return `${this.constructor.name}/JS ${VERSION}`;
   }
-
-  private debug(action: string, ...args: any[]) {
-    if (typeof process !== 'undefined' && process.env['DEBUG'] === 'true') {
-      console.log(`${this.constructor.name}:DEBUG:${action}`, ...args);
-    }
-  }
 }
 
 export class APIResource {
@@ -436,9 +529,14 @@ export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
   #client: APIClient;
   protected options: FinalRequestOptions;
 
-  constructor(client: APIClient, response: APIResponse<unknown>, options: FinalRequestOptions) {
+  protected response: Response;
+  protected body: unknown;
+
+  constructor(client: APIClient, response: Response, body: unknown, options: FinalRequestOptions) {
     this.#client = client;
     this.options = options;
+    this.response = response;
+    this.body = body;
   }
 
   /**
@@ -495,35 +593,33 @@ export abstract class AbstractPage<Item> implements AsyncIterable<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 Promise<PageClass>
+  extends APIPromise<PageClass>
   implements AsyncIterable<Item>
 {
-  /**
-   * This subclass of Promise will resolve to an instantiated Page once the request completes.
-   */
   constructor(
     client: APIClient,
-    requestPromise: Promise<APIResponse<unknown>>,
-    options: FinalRequestOptions,
+    request: Promise<APIResponseProps>,
     Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
   ) {
-    super((resolve, reject) =>
-      requestPromise.then((response) => resolve(new Page(client, response, options))).catch(reject),
+    super(
+      request,
+      async (props) => new Page(client, props.response, await defaultParseResponse(props), props.options),
     );
   }
 
-  /**
-   * Enable subclassing Promise.
-   * Ref: https://stackoverflow.com/a/60328122
-   */
-  static get [Symbol.species]() {
-    return Promise;
-  }
-
   /**
    * Allow auto-paginating iteration on an unawaited list call, eg:
    *
@@ -610,11 +706,6 @@ export type FinalRequestOptions<Req extends {} = Record<string, unknown> | Reada
   path: string;
 };
 
-export type APIResponse<T> = T & {
-  /** @deprecated - we plan to add a different way to access raw response information shortly. */
-  responseHeaders: Headers;
-};
-
 declare const Deno: any;
 declare const EdgeRuntime: any;
 type Arch = 'x32' | 'x64' | 'arm' | 'arm64' | `other:${string}` | 'unknown';
@@ -628,12 +719,13 @@ type PlatformName =
   | 'Android'
   | `Other:${string}`
   | 'Unknown';
+type Browser = 'ie' | 'edge' | 'chrome' | 'firefox' | 'safari';
 type PlatformProperties = {
   'X-Stainless-Lang': 'js';
   'X-Stainless-Package-Version': string;
   'X-Stainless-OS': PlatformName;
   'X-Stainless-Arch': Arch;
-  'X-Stainless-Runtime': 'node' | 'deno' | 'edge' | 'unknown';
+  'X-Stainless-Runtime': 'node' | 'deno' | 'edge' | `browser:${Browser}` | 'unknown';
   'X-Stainless-Runtime-Version': string;
 };
 const getPlatformProperties = (): PlatformProperties => {
@@ -668,7 +760,20 @@ const getPlatformProperties = (): PlatformProperties => {
       'X-Stainless-Runtime-Version': process.version,
     };
   }
-  // TODO add support for Cloudflare workers, browsers, etc.
+
+  const browserInfo = getBrowserInfo();
+  if (browserInfo) {
+    return {
+      'X-Stainless-Lang': 'js',
+      'X-Stainless-Package-Version': VERSION,
+      'X-Stainless-OS': 'Unknown',
+      'X-Stainless-Arch': 'unknown',
+      'X-Stainless-Runtime': `browser:${browserInfo.browser}`,
+      'X-Stainless-Runtime-Version': browserInfo.version,
+    };
+  }
+
+  // TODO add support for Cloudflare workers, etc.
   return {
     'X-Stainless-Lang': 'js',
     'X-Stainless-Package-Version': VERSION,
@@ -679,6 +784,44 @@ const getPlatformProperties = (): PlatformProperties => {
   };
 };
 
+type BrowserInfo = {
+  browser: Browser;
+  version: string;
+};
+
+declare const navigator: { userAgent: string } | undefined;
+
+// Note: modified from https://github.com/JS-DevTools/host-environment/blob/b1ab79ecde37db5d6e163c050e54fe7d287d7c92/src/isomorphic.browser.ts
+function getBrowserInfo(): BrowserInfo | null {
+  if (!navigator || typeof navigator === 'undefined') {
+    return null;
+  }
+
+  // NOTE: The order matters here!
+  const browserPatterns = [
+    { key: 'edge' as const, pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'ie' as const, pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'ie' as const, pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'chrome' as const, pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'firefox' as const, pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'safari' as const, pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ },
+  ];
+
+  // Find the FIRST matching browser
+  for (const { key, pattern } of browserPatterns) {
+    const match = pattern.exec(navigator.userAgent);
+    if (match) {
+      const major = match[1] || 0;
+      const minor = match[2] || 0;
+      const patch = match[3] || 0;
+
+      return { browser: key, version: `${major}.${minor}.${patch}` };
+    }
+  }
+
+  return null;
+}
+
 const normalizeArch = (arch: string): Arch => {
   // Node docs:
   // - https://nodejs.org/api/process.html#processarch
@@ -737,8 +880,8 @@ const isAbsoluteURL = (url: string): boolean => {
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const validatePositiveInteger = (name: string, n: number) => {
-  if (!Number.isInteger(n)) {
+const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
     throw new Error(`${name} must be an integer`);
   }
   if (n < 0) {
@@ -757,6 +900,21 @@ export const ensurePresent = <T>(value: T | null | undefined): T => {
   return value;
 };
 
+/**
+ * Read an environment variable.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+export const readEnv = (env: string): string | undefined => {
+  if (typeof process !== 'undefined') {
+    return process.env?.[env] ?? undefined;
+  }
+  if (typeof Deno !== 'undefined') {
+    return Deno.env?.get?.(env);
+  }
+  return undefined;
+};
+
 export const coerceInteger = (value: unknown): number => {
   if (typeof value === 'number') return Math.round(value);
   if (typeof value === 'string') return parseInt(value, 10);
@@ -777,6 +935,27 @@ export const coerceBoolean = (value: unknown): boolean => {
   return Boolean(value);
 };
 
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};
+
 // https://stackoverflow.com/a/34491287
 export function isEmptyObj(obj: Object | null | undefined): boolean {
   if (!obj) return true;
@@ -789,6 +968,12 @@ export function hasOwn(obj: Object, key: string): boolean {
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
+export function debug(action: string, ...args: any[]) {
+  if (typeof process !== 'undefined' && process.env['DEBUG'] === 'true') {
+    console.log(`Increase:DEBUG:${action}`, ...args);
+  }
+}
+
 /**
  * https://stackoverflow.com/a/2117523
  */
@@ -800,6 +985,17 @@ const uuid4 = () => {
   });
 };
 
+export const isRunningInBrowser = () => {
+  return (
+    // @ts-ignore
+    typeof window !== 'undefined' &&
+    // @ts-ignore
+    typeof window.document !== 'undefined' &&
+    // @ts-ignore
+    typeof navigator !== 'undefined'
+  );
+};
+
 export interface HeadersProtocol {
   get: (header: string) => string | null | undefined;
 }

package/src/error.ts

@@ -13,12 +13,22 @@ export class APIError extends Error {
     message: string | undefined,
     headers: Headers | undefined,
   ) {
-    super(message || (error as any)?.message || 'Unknown error occurred.');
+    super(APIError.makeMessage(error, message));
     this.status = status;
     this.headers = headers;
     this.error = error;
   }
 
+  private static makeMessage(error: any, message: string | undefined) {
+    return (
+      error?.message ?
+        typeof error.message === 'string' ? error.message
+        : JSON.stringify(error.message)
+      : error ? JSON.stringify(error)
+      : message || 'Unknown error occurred'
+    );
+  }
+
   static generate(
     status: number | undefined,
     errorResponse: Object | undefined,

package/src/index.ts

@@ -89,19 +89,19 @@ export class Increase extends Core.APIClient {
 
   private _options: ClientOptions;
 
-  constructor(opts?: ClientOptions) {
+  constructor({ apiKey = Core.readEnv('INCREASE_API_KEY'), ...opts }: ClientOptions = {}) {
+    if (apiKey === undefined) {
+      throw new Error(
+        'The INCREASE_API_KEY environment variable is missing or empty; either provide it, or instantiate the Increase client with an apiKey option, like new Increase({ apiKey: undefined }).',
+      );
+    }
+
     const options: ClientOptions = {
-      apiKey: typeof process === 'undefined' ? '' : process.env['INCREASE_API_KEY'] || '',
+      apiKey,
       environment: 'production',
       ...opts,
     };
 
-    if (!options.apiKey && options.apiKey !== null) {
-      throw new Error(
-        "The INCREASE_API_KEY environment variable is missing or empty; either provide it, or instantiate the Increase client with an apiKey option, like new Increase({ apiKey: 'my api key' }).",
-      );
-    }
-
     super({
       baseURL: options.baseURL || environments[options.environment || 'production'],
       timeout: options.timeout,
@@ -109,9 +109,10 @@ export class Increase extends Core.APIClient {
       maxRetries: options.maxRetries,
       fetch: options.fetch,
     });
-    this.apiKey = options.apiKey;
     this._options = options;
     this.idempotencyHeader = 'Idempotency-Key';
+
+    this.apiKey = apiKey;
   }
 
   accounts: API.Accounts = new API.Accounts(this);
@@ -125,6 +126,7 @@ export class Increase extends Core.APIClient {
   cards: API.Cards = new API.Cards(this);
   cardDisputes: API.CardDisputes = new API.CardDisputes(this);
   cardProfiles: API.CardProfiles = new API.CardProfiles(this);
+  cardPurchaseSupplements: API.CardPurchaseSupplements = new API.CardPurchaseSupplements(this);
   externalAccounts: API.ExternalAccounts = new API.ExternalAccounts(this);
   exports: API.Exports = new API.Exports(this);
   digitalWalletTokens: API.DigitalWalletTokens = new API.DigitalWalletTokens(this);
@@ -304,6 +306,11 @@ export namespace Increase {
   export import CardProfileCreateParams = API.CardProfileCreateParams;
   export import CardProfileListParams = API.CardProfileListParams;
 
+  export import CardPurchaseSupplements = API.CardPurchaseSupplements;
+  export import CardPurchaseSupplement = API.CardPurchaseSupplement;
+  export import CardPurchaseSupplementsPage = API.CardPurchaseSupplementsPage;
+  export import CardPurchaseSupplementListParams = API.CardPurchaseSupplementListParams;
+
   export import ExternalAccounts = API.ExternalAccounts;
   export import ExternalAccount = API.ExternalAccount;
   export import ExternalAccountsPage = API.ExternalAccountsPage;

package/src/pagination.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless.
 
-import { AbstractPage, APIResponse, APIClient, FinalRequestOptions, PageInfo } from './core';
+import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from './core';
 
 /**
  * A list of Account objects
@@ -35,11 +35,11 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
    */
   next_cursor: string | null;
 
-  constructor(client: APIClient, response: APIResponse<PageResponse<Item>>, options: FinalRequestOptions) {
-    super(client, response, options);
+  constructor(client: APIClient, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
+    super(client, response, body, options);
 
-    this.data = response.data;
-    this.next_cursor = response.next_cursor;
+    this.data = body.data;
+    this.next_cursor = body.next_cursor;
   }
 
   getPaginatedItems(): Item[] {

package/src/resources/account-numbers.ts

@@ -3,24 +3,21 @@
 import * as Core from '../core';
 import { APIResource } from '../resource';
 import { isRequestOptions } from '../core';
-import * as API from '.';
+import * as API from './index';
 import { Page, PageParams } from '../pagination';
 
 export class AccountNumbers extends APIResource {
   /**
    * Create an Account Number
    */
-  create(
-    body: AccountNumberCreateParams,
-    options?: Core.RequestOptions,
-  ): Promise<Core.APIResponse<AccountNumber>> {
+  create(body: AccountNumberCreateParams, options?: Core.RequestOptions): Core.APIPromise<AccountNumber> {
     return this.post('/account_numbers', { body, ...options });
   }
 
   /**
    * Retrieve an Account Number
    */
-  retrieve(accountNumberId: string, options?: Core.RequestOptions): Promise<Core.APIResponse<AccountNumber>> {
+  retrieve(accountNumberId: string, options?: Core.RequestOptions): Core.APIPromise<AccountNumber> {
     return this.get(`/account_numbers/${accountNumberId}`, options);
   }
 
@@ -31,19 +28,22 @@ export class AccountNumbers extends APIResource {
     accountNumberId: string,
     body: AccountNumberUpdateParams,
     options?: Core.RequestOptions,
-  ): Promise<Core.APIResponse<AccountNumber>> {
+  ): Core.APIPromise<AccountNumber> {
     return this.patch(`/account_numbers/${accountNumberId}`, { body, ...options });
   }
 
   /**
    * List Account Numbers
    */
-  list(query?: AccountNumberListParams, options?: Core.RequestOptions): Core.PagePromise<AccountNumbersPage>;
-  list(options?: Core.RequestOptions): Core.PagePromise<AccountNumbersPage>;
+  list(
+    query?: AccountNumberListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<AccountNumbersPage, AccountNumber>;
+  list(options?: Core.RequestOptions): Core.PagePromise<AccountNumbersPage, AccountNumber>;
   list(
     query: AccountNumberListParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.PagePromise<AccountNumbersPage> {
+  ): Core.PagePromise<AccountNumbersPage, AccountNumber> {
     if (isRequestOptions(query)) {
       return this.list({}, query);
     }