Merge upstream and update generated code for v2204 and

Author: stripe-openapi[bot]

CODEGEN_VERSION

@@ -1 +1 @@
-273184f052dd3c191b1993098365d0c2437d2cb4
+19704d8af6f1949f2d8f646ca37978ad12f936a4

src/StripeResource.ts

@@ -1,4 +1,5 @@
 import {
+  getAPIMode,
   getDataFromArgs,
   getOptionsFromArgs,
   makeURLInterpolator,
@@ -16,6 +17,7 @@ import {
   UrlInterpolator,
 } from './Types.js';
 import {HttpClientResponseInterface} from './net/HttpClient.js';
+import {coerceV2RequestData, coerceV2ResponseData} from './V2Int64.js';
 
 // Provide extension mechanism for Stripe Resource Sub-Classes
 StripeResource.extend = protoExtend;
@@ -209,18 +211,35 @@ StripeResource.prototype = {
         return;
       }
 
+      // Coerce int64_string fields in request body: number → string
+      const apiMode = getAPIMode(spec.fullPath || spec.path);
+      if (apiMode === 'v2' && spec.requestSchema && opts.bodyData) {
+        opts.bodyData = coerceV2RequestData(
+          opts.bodyData,
+          spec.requestSchema
+        ) as RequestData;
+      }
+
       function requestCallback(
         err: any,
         response: HttpClientResponseInterface
       ): void {
         if (err) {
           reject(err);
         } else {
-          resolve(
-            spec.transformResponseData
-              ? spec.transformResponseData(response)
-              : response
-          );
+          // Coerce int64_string fields in response: string → bigint
+          try {
+            if (apiMode === 'v2' && spec.responseSchema) {
+              coerceV2ResponseData(response, spec.responseSchema);
+            }
+            resolve(
+              spec.transformResponseData
+                ? spec.transformResponseData(response)
+                : response
+            );
+          } catch (e) {
+            reject(e);
+          }
         }
       }
 

src/Types.d.ts

@@ -15,6 +15,11 @@ export type BufferedFile = {
   type: string;
   file: {data: Uint8Array};
 };
+export type V2RuntimeSchema =
+  | {kind: 'int64_string'}
+  | {kind: 'object'; fields: Record<string, V2RuntimeSchema>}
+  | {kind: 'array'; element: V2RuntimeSchema}
+  | {kind: 'nullable'; inner: V2RuntimeSchema};
 export type MethodSpec = {
   method: string;
   methodType?: string;
@@ -28,6 +33,8 @@ export type MethodSpec = {
   host?: string;
   transformResponseData?: (response: HttpClientResponseInterface) => any;
   usage?: Array<string>;
+  requestSchema?: V2RuntimeSchema;
+  responseSchema?: V2RuntimeSchema;
 };
 export type MultipartRequestData = RequestData | StreamingFile | BufferedFile;
 // rawErrorTypeEnum: The beginning of the section generated from our OpenAPI spec
@@ -39,6 +46,11 @@ export type RawErrorType =
   | 'rate_limit_error'
   | 'authentication_error'
   | 'invalid_grant'
+  | 'invalid_client'
+  | 'invalid_request'
+  | 'invalid_scope'
+  | 'unsupported_grant_type'
+  | 'unsupported_response_type'
   | 'already_canceled'
   | 'already_exists'
   | 'blocked_by_stripe'

src/V2Int64.ts

@@ -0,0 +1,107 @@
+import {V2RuntimeSchema} from './Types.js';
+
+/**
+ * Coerces outbound V2 request data by converting bigint (or number)
+ * int64_string fields to strings, matching the wire format expected by the API.
+ *
+ * Walks the schema tree and only touches fields that are marked as
+ * int64_string. All other values are left unchanged.
+ */
+export const coerceV2RequestData = (
+  data: unknown,
+  schema: V2RuntimeSchema
+): unknown => {
+  if (data == null) {
+    return data;
+  }
+
+  switch (schema.kind) {
+    case 'int64_string':
+      return typeof data === 'bigint' || typeof data === 'number'
+        ? String(data)
+        : data;
+
+    case 'object': {
+      if (typeof data !== 'object' || Array.isArray(data)) {
+        return data;
+      }
+      const obj = data as Record<string, unknown>;
+      const result: Record<string, unknown> = {};
+      for (const key of Object.keys(obj)) {
+        const fieldSchema = schema.fields[key];
+        result[key] = fieldSchema
+          ? coerceV2RequestData(obj[key], fieldSchema)
+          : obj[key];
+      }
+      return result;
+    }
+
+    case 'array': {
+      if (!Array.isArray(data)) {
+        return data;
+      }
+      return data.map((element) =>
+        coerceV2RequestData(element, schema.element)
+      );
+    }
+
+    case 'nullable':
+      return coerceV2RequestData(data, schema.inner);
+  }
+};
+
+/**
+ * Coerces inbound V2 response data by converting string int64_string fields
+ * to bigints, matching the SDK's public type contract.
+ *
+ * Walks the schema tree and only touches fields that are marked as
+ * int64_string. All other values are left unchanged.
+ */
+export const coerceV2ResponseData = (
+  data: unknown,
+  schema: V2RuntimeSchema
+): unknown => {
+  if (data == null) {
+    return data;
+  }
+
+  switch (schema.kind) {
+    case 'int64_string':
+      if (typeof data === 'string') {
+        try {
+          return BigInt(data);
+        } catch {
+          throw new Error(
+            `Failed to coerce int64_string value: expected an integer string, got '${data}'`
+          );
+        }
+      }
+      return data;
+
+    case 'object': {
+      if (typeof data !== 'object' || Array.isArray(data)) {
+        return data;
+      }
+      const obj = data as Record<string, unknown>;
+      for (const key of Object.keys(schema.fields)) {
+        if (key in obj) {
+          obj[key] = coerceV2ResponseData(obj[key], schema.fields[key]);
+        }
+      }
+      return obj;
+    }
+
+    case 'array': {
+      if (!Array.isArray(data)) {
+        return data;
+      }
+      for (let i = 0; i < data.length; i++) {
+        data[i] = coerceV2ResponseData(data[i], schema.element);
+      }
+      return data;
+    }
+
+    case 'nullable':
+      return coerceV2ResponseData(data, schema.inner);
+  }
+};