stripe 16.13.0-beta.1 → 17.1.0

package/esm/Error.js

@@ -1,5 +1,6 @@
 /* eslint-disable camelcase */
-export const generate = (rawStripeError) => {
+/* eslint-disable no-warning-comments */
+export const generateV1Error = (rawStripeError) => {
     switch (rawStripeError.type) {
         case 'card_error':
             return new StripeCardError(rawStripeError);
@@ -19,6 +20,22 @@ export const generate = (rawStripeError) => {
             return new StripeUnknownError(rawStripeError);
     }
 };
+// eslint-disable-next-line complexity
+export const generateV2Error = (rawStripeError) => {
+    switch (rawStripeError.type) {
+        // switchCases: The beginning of the section generated from our OpenAPI spec
+        case 'temporary_session_expired':
+            return new TemporarySessionExpiredError(rawStripeError);
+        // switchCases: The end of the section generated from our OpenAPI spec
+    }
+    // Special handling for requests with missing required fields in V2 APIs.
+    // invalid_field response in V2 APIs returns the field 'code' instead of 'type'.
+    switch (rawStripeError.code) {
+        case 'invalid_fields':
+            return new StripeInvalidRequestError(rawStripeError);
+    }
+    return generateV1Error(rawStripeError);
+};
 /**
  * StripeError is the base error from which all other more specific Stripe errors derive.
  * Specifically for errors returned from Stripe's REST API.
@@ -38,6 +55,7 @@ export class StripeError extends Error {
         this.statusCode = raw.statusCode;
         // @ts-ignore
         this.message = raw.message;
+        this.userMessage = raw.user_message;
         this.charge = raw.charge;
         this.decline_code = raw.decline_code;
         this.payment_intent = raw.payment_intent;
@@ -50,7 +68,7 @@ export class StripeError extends Error {
 /**
  * Helper factory which takes raw stripe errors and outputs wrapping instances
  */
-StripeError.generate = generate;
+StripeError.generate = generateV1Error;
 // Specific Stripe Error types:
 /**
  * CardError is raised when a user enters a card that can't be charged for
@@ -158,3 +176,10 @@ export class StripeUnknownError extends StripeError {
         super(raw, 'StripeUnknownError');
     }
 }
+// classDefinitions: The beginning of the section generated from our OpenAPI spec
+export class TemporarySessionExpiredError extends StripeError {
+    constructor(rawStripeError = {}) {
+        super(rawStripeError, 'TemporarySessionExpiredError');
+    }
+}
+// classDefinitions: The end of the section generated from our OpenAPI spec

package/esm/RequestSender.js

@@ -1,7 +1,6 @@
-import { StripeAPIError, StripeAuthenticationError, StripeConnectionError, StripeError, StripePermissionError, StripeRateLimitError, } from './Error.js';
-import { emitWarning, jsonStringifyRequestData, normalizeHeaders, removeNullish, queryStringifyRequestData, getDataFromArgs, getOptionsFromArgs, } from './utils.js';
+import { StripeAPIError, StripeAuthenticationError, StripeConnectionError, StripeError, StripePermissionError, StripeRateLimitError, generateV1Error, generateV2Error, } from './Error.js';
 import { HttpClient } from './net/HttpClient.js';
-import { PreviewVersion } from './apiVersion.js';
+import { emitWarning, jsonStringifyRequestData, normalizeHeaders, queryStringifyRequestData, removeNullish, getAPIMode, getOptionsFromArgs, getDataFromArgs, } from './utils.js';
 const MAX_RETRY_AFTER_WAIT = 60;
 export class RequestSender {
     constructor(stripe, maxBufferedRequestMetric) {
@@ -67,7 +66,7 @@ export class RequestSender {
      * parses the JSON and returns it (i.e. passes it to the callback) if there
      * is no "error" field. Otherwise constructs/passes an appropriate Error.
      */
-    _jsonResponseHandler(requestEvent, usage, callback) {
+    _jsonResponseHandler(requestEvent, apiMode, usage, callback) {
         return (res) => {
             const headers = res.getHeaders();
             const requestId = this._getRequestId(headers);
@@ -99,8 +98,11 @@ export class RequestSender {
                     else if (statusCode === 429) {
                         err = new StripeRateLimitError(jsonResponse.error);
                     }
+                    else if (apiMode === 'v2') {
+                        err = generateV2Error(jsonResponse.error);
+                    }
                     else {
-                        err = StripeError.generate(jsonResponse.error);
+                        err = generateV1Error(jsonResponse.error);
                     }
                     throw err;
                 }
@@ -172,7 +174,7 @@ export class RequestSender {
         // Apply exponential backoff with initialNetworkRetryDelay on the
         // number of numRetries so far as inputs. Do not allow the number to exceed
         // maxNetworkRetryDelay.
-        let sleepSeconds = Math.min(initialNetworkRetryDelay * Math.pow(numRetries - 1, 2), maxNetworkRetryDelay);
+        let sleepSeconds = Math.min(initialNetworkRetryDelay * Math.pow(2, numRetries - 1), maxNetworkRetryDelay);
         // Apply some jitter by randomizing the value in the range of
         // (sleepSeconds / 2) to (sleepSeconds).
         sleepSeconds *= 0.5 * (1 + Math.random());
@@ -191,26 +193,34 @@ export class RequestSender {
             ? settings.maxNetworkRetries
             : this._stripe.getMaxNetworkRetries();
     }
-    _defaultIdempotencyKey(method, settings) {
+    _defaultIdempotencyKey(method, settings, apiMode) {
         // If this is a POST and we allow multiple retries, ensure an idempotency key.
         const maxRetries = this._getMaxNetworkRetries(settings);
-        if (method === 'POST' && maxRetries > 0) {
-            return `stripe-node-retry-${this._stripe._platformFunctions.uuid4()}`;
+        const genKey = () => `stripe-node-retry-${this._stripe._platformFunctions.uuid4()}`;
+        // more verbose than it needs to be, but gives clear separation between V1 and V2 behavior
+        if (apiMode === 'v2') {
+            if (method === 'POST' || method === 'DELETE') {
+                return genKey();
+            }
+        }
+        else if (apiMode === 'v1') {
+            if (method === 'POST' && maxRetries > 0) {
+                return genKey();
+            }
         }
         return null;
     }
-    _makeHeaders(auth, contentType, contentLength, apiVersion, clientUserAgent, method, userSuppliedHeaders, userSuppliedSettings) {
+    _makeHeaders({ contentType, contentLength, apiVersion, clientUserAgent, method, userSuppliedHeaders, userSuppliedSettings, stripeAccount, stripeContext, apiMode, }) {
         const defaultHeaders = {
-            // Use specified auth token or use default from this stripe instance:
-            Authorization: auth ? `Bearer ${auth}` : this._stripe.getApiField('auth'),
             Accept: 'application/json',
             'Content-Type': contentType,
-            'User-Agent': this._getUserAgentString(),
+            'User-Agent': this._getUserAgentString(apiMode),
             'X-Stripe-Client-User-Agent': clientUserAgent,
             'X-Stripe-Client-Telemetry': this._getTelemetryHeader(),
             'Stripe-Version': apiVersion,
-            'Stripe-Account': this._stripe.getApiField('stripeAccount'),
-            'Idempotency-Key': this._defaultIdempotencyKey(method, userSuppliedSettings),
+            'Stripe-Account': stripeAccount,
+            'Stripe-Context': stripeContext,
+            'Idempotency-Key': this._defaultIdempotencyKey(method, userSuppliedSettings, apiMode),
         };
         // As per https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.2:
         //   A user agent SHOULD send a Content-Length in a request message when
@@ -239,12 +249,12 @@ export class RequestSender {
         // If the user supplied, say 'idempotency-key', override instead of appending by ensuring caps are the same.
         normalizeHeaders(userSuppliedHeaders));
     }
-    _getUserAgentString() {
+    _getUserAgentString(apiMode) {
         const packageVersion = this._stripe.getConstant('PACKAGE_VERSION');
         const appInfo = this._stripe._appInfo
             ? this._stripe.getAppInfoAsString()
             : '';
-        return `Stripe/v1 NodeBindings/${packageVersion} ${appInfo}`.trim();
+        return `Stripe/${apiMode} NodeBindings/${packageVersion} ${appInfo}`.trim();
     }
     _getTelemetryHeader() {
         if (this._stripe.getTelemetryEnabled() &&
@@ -287,19 +297,19 @@ export class RequestSender {
                 const dataFromArgs = getDataFromArgs(args);
                 const data = Object.assign({}, dataFromArgs);
                 const calculatedOptions = getOptionsFromArgs(args);
-                const apiMode = calculatedOptions.apiMode || 'standard';
                 const headers = calculatedOptions.headers;
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const authenticator = calculatedOptions.authenticator;
                 opts = {
                     requestMethod,
                     requestPath: path,
                     bodyData: data,
                     queryData: {},
-                    auth: calculatedOptions.auth,
+                    authenticator,
                     headers,
                     host: null,
                     streaming: false,
                     settings: {},
-                    apiMode: apiMode,
                     usage: ['raw_request'],
                 };
             }
@@ -316,12 +326,17 @@ export class RequestSender {
                 }
             }
             const { headers, settings } = opts;
-            this._request(opts.requestMethod, opts.host, path, opts.bodyData, opts.auth, { headers, settings, streaming: opts.streaming, apiMode: opts.apiMode }, opts.usage, requestCallback);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const authenticator = opts.authenticator;
+            this._request(opts.requestMethod, opts.host, path, opts.bodyData, authenticator, { headers, settings, streaming: opts.streaming }, opts.usage, requestCallback);
         });
         return requestPromise;
     }
-    _request(method, host, path, data, auth, options = {}, usage = [], callback, requestDataProcessor = null) {
+    _request(method, host, path, data, authenticator, options, usage = [], callback, requestDataProcessor = null) {
+        var _a;
         let requestData;
+        authenticator = (_a = authenticator !== null && authenticator !== void 0 ? authenticator : this._stripe._authenticator) !== null && _a !== void 0 ? _a : null;
+        const apiMode = getAPIMode(path);
         const retryRequest = (requestFn, apiVersion, headers, requestRetries, retryAfter) => {
             return setTimeout(requestFn, this._getSleepTimeInMS(requestRetries, retryAfter), apiVersion, headers, requestRetries + 1);
         };
@@ -333,50 +348,68 @@ export class RequestSender {
                 options.settings.timeout >= 0
                 ? options.settings.timeout
                 : this._stripe.getApiField('timeout');
-            const req = this._stripe
-                .getApiField('httpClient')
-                .makeRequest(host || this._stripe.getApiField('host'), this._stripe.getApiField('port'), path, method, headers, requestData, this._stripe.getApiField('protocol'), timeout);
-            const requestStartTime = Date.now();
-            // @ts-ignore
-            const requestEvent = removeNullish({
-                api_version: apiVersion,
-                account: headers['Stripe-Account'],
-                idempotency_key: headers['Idempotency-Key'],
-                method,
-                path,
-                request_start_time: requestStartTime,
-            });
-            const requestRetries = numRetries || 0;
-            const maxRetries = this._getMaxNetworkRetries(options.settings || {});
-            this._stripe._emitter.emit('request', requestEvent);
-            req
-                .then((res) => {
-                if (RequestSender._shouldRetry(res, requestRetries, maxRetries)) {
-                    return retryRequest(makeRequest, apiVersion, headers, requestRetries, 
-                    // @ts-ignore
-                    res.getHeaders()['retry-after']);
-                }
-                else if (options.streaming && res.getStatusCode() < 400) {
-                    return this._streamingResponseHandler(requestEvent, usage, callback)(res);
-                }
-                else {
-                    return this._jsonResponseHandler(requestEvent, usage, callback)(res);
-                }
-            })
-                .catch((error) => {
-                if (RequestSender._shouldRetry(null, requestRetries, maxRetries, error)) {
-                    return retryRequest(makeRequest, apiVersion, headers, requestRetries, null);
-                }
-                else {
-                    const isTimeoutError = error.code && error.code === HttpClient.TIMEOUT_ERROR_CODE;
-                    return callback(new StripeConnectionError({
-                        message: isTimeoutError
-                            ? `Request aborted due to timeout being reached (${timeout}ms)`
-                            : RequestSender._generateConnectionErrorMessage(requestRetries),
+            const request = {
+                host: host || this._stripe.getApiField('host'),
+                port: this._stripe.getApiField('port'),
+                path: path,
+                method: method,
+                headers: Object.assign({}, headers),
+                body: requestData,
+                protocol: this._stripe.getApiField('protocol'),
+            };
+            authenticator(request)
+                .then(() => {
+                const req = this._stripe
+                    .getApiField('httpClient')
+                    .makeRequest(request.host, request.port, request.path, request.method, request.headers, request.body, request.protocol, timeout);
+                const requestStartTime = Date.now();
+                // @ts-ignore
+                const requestEvent = removeNullish({
+                    api_version: apiVersion,
+                    account: headers['Stripe-Account'],
+                    idempotency_key: headers['Idempotency-Key'],
+                    method,
+                    path,
+                    request_start_time: requestStartTime,
+                });
+                const requestRetries = numRetries || 0;
+                const maxRetries = this._getMaxNetworkRetries(options.settings || {});
+                this._stripe._emitter.emit('request', requestEvent);
+                req
+                    .then((res) => {
+                    if (RequestSender._shouldRetry(res, requestRetries, maxRetries)) {
+                        return retryRequest(makeRequest, apiVersion, headers, requestRetries, 
                         // @ts-ignore
-                        detail: error,
-                    }));
-                }
+                        res.getHeaders()['retry-after']);
+                    }
+                    else if (options.streaming && res.getStatusCode() < 400) {
+                        return this._streamingResponseHandler(requestEvent, usage, callback)(res);
+                    }
+                    else {
+                        return this._jsonResponseHandler(requestEvent, apiMode, usage, callback)(res);
+                    }
+                })
+                    .catch((error) => {
+                    if (RequestSender._shouldRetry(null, requestRetries, maxRetries, error)) {
+                        return retryRequest(makeRequest, apiVersion, headers, requestRetries, null);
+                    }
+                    else {
+                        const isTimeoutError = error.code && error.code === HttpClient.TIMEOUT_ERROR_CODE;
+                        return callback(new StripeConnectionError({
+                            message: isTimeoutError
+                                ? `Request aborted due to timeout being reached (${timeout}ms)`
+                                : RequestSender._generateConnectionErrorMessage(requestRetries),
+                            // @ts-ignore
+                            detail: error,
+                        }));
+                    }
+                });
+            })
+                .catch((e) => {
+                throw new StripeError({
+                    message: 'Unable to authenticate the request',
+                    exception: e,
+                });
             });
         };
         const prepareAndMakeRequest = (error, data) => {
@@ -384,15 +417,22 @@ export class RequestSender {
                 return callback(error);
             }
             requestData = data;
-            let contentType = 'application/x-www-form-urlencoded';
-            let apiVersion = this._stripe.getApiField('version');
-            if (options.apiMode === 'preview') {
-                contentType = 'application/json';
-                apiVersion = PreviewVersion;
-            }
             this._stripe.getClientUserAgent((clientUserAgent) => {
-                var _a, _b;
-                const headers = this._makeHeaders(auth, contentType, requestData.length, apiVersion, clientUserAgent, method, (_a = options.headers) !== null && _a !== void 0 ? _a : null, (_b = options.settings) !== null && _b !== void 0 ? _b : {});
+                const apiVersion = this._stripe.getApiField('version');
+                const headers = this._makeHeaders({
+                    contentType: apiMode == 'v2'
+                        ? 'application/json'
+                        : 'application/x-www-form-urlencoded',
+                    contentLength: requestData.length,
+                    apiVersion: apiVersion,
+                    clientUserAgent,
+                    method,
+                    userSuppliedHeaders: options.headers,
+                    userSuppliedSettings: options.settings,
+                    stripeAccount: apiMode == 'v2' ? null : this._stripe.getApiField('stripeAccount'),
+                    stripeContext: apiMode == 'v2' ? this._stripe.getApiField('stripeContext') : null,
+                    apiMode: apiMode,
+                });
                 makeRequest(apiVersion, headers, 0);
             });
         };
@@ -401,11 +441,11 @@ export class RequestSender {
         }
         else {
             let stringifiedData;
-            if (options.apiMode === 'preview') {
+            if (apiMode == 'v2') {
                 stringifiedData = data ? jsonStringifyRequestData(data) : '';
             }
             else {
-                stringifiedData = queryStringifyRequestData(data || {});
+                stringifiedData = queryStringifyRequestData(data || {}, apiMode);
             }
             prepareAndMakeRequest(null, stringifiedData);
         }

package/esm/StripeResource.js

@@ -1,4 +1,4 @@
-import { getDataFromArgs, getOptionsFromArgs, makeURLInterpolator, protoExtend, queryStringifyRequestData, } from './utils.js';
+import { getDataFromArgs, getOptionsFromArgs, makeURLInterpolator, protoExtend, queryStringifyRequestData, getAPIMode, } from './utils.js';
 import { stripeMethod } from './StripeMethod.js';
 // Provide extension mechanism for Stripe Resource Sub-Classes
 StripeResource.extend = protoExtend;
@@ -75,6 +75,7 @@ StripeResource.prototype = {
         return parts.join('/').replace(/\/{2,}/g, '/');
     },
     _getRequestOpts(requestArgs, spec, overrideData) {
+        var _a;
         // Extract spec values with defaults.
         const requestMethod = (spec.method || 'GET').toUpperCase();
         const usage = spec.usage || [];
@@ -125,7 +126,7 @@ StripeResource.prototype = {
             requestPath,
             bodyData,
             queryData,
-            auth: options.auth,
+            authenticator: (_a = options.authenticator) !== null && _a !== void 0 ? _a : null,
             headers,
             host: host !== null && host !== void 0 ? host : null,
             streaming,
@@ -158,10 +159,14 @@ StripeResource.prototype = {
             const path = [
                 opts.requestPath,
                 emptyQuery ? '' : '?',
-                queryStringifyRequestData(opts.queryData),
+                queryStringifyRequestData(opts.queryData, getAPIMode(opts.requestPath)),
             ].join('');
             const { headers, settings } = opts;
-            this._stripe._requestSender._request(opts.requestMethod, opts.host, path, opts.bodyData, opts.auth, { headers, settings, streaming: opts.streaming }, opts.usage, requestCallback, (_a = this.requestDataProcessor) === null || _a === void 0 ? void 0 : _a.bind(this));
+            this._stripe._requestSender._request(opts.requestMethod, opts.host, path, opts.bodyData, opts.authenticator, {
+                headers,
+                settings,
+                streaming: opts.streaming,
+            }, opts.usage, requestCallback, (_a = this.requestDataProcessor) === null || _a === void 0 ? void 0 : _a.bind(this));
         });
     },
 };

package/esm/apiVersion.js

@@ -1,3 +1,2 @@
 // File generated from our OpenAPI spec
-export const ApiVersion = '2024-06-20';
-export const PreviewVersion = 'cs_ubb_launch';
+export const ApiVersion = '2024-09-30.acacia';

package/esm/autoPagination.js

@@ -1,5 +1,5 @@
-import { callbackifyPromiseWithTimeout, getDataFromArgs } from './utils.js';
-class StripeIterator {
+import { callbackifyPromiseWithTimeout, getDataFromArgs, getAPIMode, } from './utils.js';
+class V1Iterator {
     constructor(firstPagePromise, requestArgs, spec, stripeResource) {
         this.index = 0;
         this.pagePromise = firstPagePromise;
@@ -57,7 +57,7 @@ class StripeIterator {
         return nextPromise;
     }
 }
-class ListIterator extends StripeIterator {
+class V1ListIterator extends V1Iterator {
     getNextPage(pageResult) {
         const reverseIteration = isReverseIteration(this.requestArgs);
         const lastId = getLastId(pageResult, reverseIteration);
@@ -66,7 +66,7 @@ class ListIterator extends StripeIterator {
         });
     }
 }
-class SearchIterator extends StripeIterator {
+class V1SearchIterator extends V1Iterator {
     getNextPage(pageResult) {
         if (!pageResult.next_page) {
             throw Error('Unexpected: Stripe API response does not have a well-formed `next_page` field, but `has_more` was true.');
@@ -76,12 +76,56 @@ class SearchIterator extends StripeIterator {
         });
     }
 }
+class V2ListIterator {
+    constructor(firstPagePromise, requestArgs, spec, stripeResource) {
+        this.currentPageIterator = (async () => {
+            const page = await firstPagePromise;
+            return page.data[Symbol.iterator]();
+        })();
+        this.nextPageUrl = (async () => {
+            const page = await firstPagePromise;
+            return page.next_page_url || null;
+        })();
+        this.requestArgs = requestArgs;
+        this.spec = spec;
+        this.stripeResource = stripeResource;
+    }
+    async turnPage() {
+        const nextPageUrl = await this.nextPageUrl;
+        if (!nextPageUrl)
+            return null;
+        this.spec.fullPath = nextPageUrl;
+        const page = await this.stripeResource._makeRequest([], this.spec, {});
+        this.nextPageUrl = Promise.resolve(page.next_page_url);
+        this.currentPageIterator = Promise.resolve(page.data[Symbol.iterator]());
+        return this.currentPageIterator;
+    }
+    async next() {
+        {
+            const result = (await this.currentPageIterator).next();
+            if (!result.done)
+                return { done: false, value: result.value };
+        }
+        const nextPageIterator = await this.turnPage();
+        if (!nextPageIterator) {
+            return { done: true, value: undefined };
+        }
+        const result = nextPageIterator.next();
+        if (!result.done)
+            return { done: false, value: result.value };
+        return { done: true, value: undefined };
+    }
+}
 export const makeAutoPaginationMethods = (stripeResource, requestArgs, spec, firstPagePromise) => {
-    if (spec.methodType === 'search') {
-        return makeAutoPaginationMethodsFromIterator(new SearchIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    const apiMode = getAPIMode(spec.fullPath || spec.path);
+    if (apiMode !== 'v2' && spec.methodType === 'search') {
+        return makeAutoPaginationMethodsFromIterator(new V1SearchIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    }
+    if (apiMode !== 'v2' && spec.methodType === 'list') {
+        return makeAutoPaginationMethodsFromIterator(new V1ListIterator(firstPagePromise, requestArgs, spec, stripeResource));
     }
-    if (spec.methodType === 'list') {
-        return makeAutoPaginationMethodsFromIterator(new ListIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    if (apiMode === 'v2' && spec.methodType === 'list') {
+        return makeAutoPaginationMethodsFromIterator(new V2ListIterator(firstPagePromise, requestArgs, spec, stripeResource));
     }
     return null;
 };

package/esm/crypto/CryptoProvider.js

@@ -28,6 +28,12 @@ export class CryptoProvider {
     computeHMACSignatureAsync(payload, secret) {
         throw new Error('computeHMACSignatureAsync not implemented.');
     }
+    /**
+     * Computes a SHA-256 hash of the data.
+     */
+    computeSHA256Async(data) {
+        throw new Error('computeSHA256 not implemented.');
+    }
 }
 /**
  * If the crypto provider only supports asynchronous operations,

package/esm/crypto/NodeCryptoProvider.js

@@ -16,4 +16,11 @@ export class NodeCryptoProvider extends CryptoProvider {
         const signature = await this.computeHMACSignature(payload, secret);
         return signature;
     }
+    /** @override */
+    async computeSHA256Async(data) {
+        return new Uint8Array(await crypto
+            .createHash('sha256')
+            .update(data)
+            .digest());
+    }
 }

package/esm/crypto/SubtleCryptoProvider.js

@@ -34,6 +34,10 @@ export class SubtleCryptoProvider extends CryptoProvider {
         }
         return signatureHexCodes.join('');
     }
+    /** @override */
+    async computeSHA256Async(data) {
+        return new Uint8Array(await this.subtleCrypto.digest('SHA-256', data));
+    }
 }
 // Cached mapping of byte to hex representation. We do this once to avoid re-
 // computing every time we need to convert the result of a signature to hex.

package/esm/resources/{Capital/FinancingSummary.js → Billing/CreditBalanceSummary.js}

@@ -1,9 +1,9 @@
 // File generated from our OpenAPI spec
 import { StripeResource } from '../../StripeResource.js';
 const stripeMethod = StripeResource.method;
-export const FinancingSummary = StripeResource.extend({
+export const CreditBalanceSummary = StripeResource.extend({
     retrieve: stripeMethod({
         method: 'GET',
-        fullPath: '/v1/capital/financing_summary',
+        fullPath: '/v1/billing/credit_balance_summary',
     }),
 });

package/esm/resources/{FinancialConnections/Institutions.js → Billing/CreditBalanceTransactions.js}

@@ -1,14 +1,14 @@
 // File generated from our OpenAPI spec
 import { StripeResource } from '../../StripeResource.js';
 const stripeMethod = StripeResource.method;
-export const Institutions = StripeResource.extend({
+export const CreditBalanceTransactions = StripeResource.extend({
     retrieve: stripeMethod({
         method: 'GET',
-        fullPath: '/v1/financial_connections/institutions/{institution}',
+        fullPath: '/v1/billing/credit_balance_transactions/{id}',
     }),
     list: stripeMethod({
         method: 'GET',
-        fullPath: '/v1/financial_connections/institutions',
+        fullPath: '/v1/billing/credit_balance_transactions',
         methodType: 'list',
     }),
 });

package/esm/resources/Billing/CreditGrants.js

@@ -0,0 +1,27 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const CreditGrants = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/billing/credit_grants' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/credit_grants/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/credit_grants/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/credit_grants',
+        methodType: 'list',
+    }),
+    expire: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/credit_grants/{id}/expire',
+    }),
+    voidGrant: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/credit_grants/{id}/void',
+    }),
+});

package/esm/resources/FinancialConnections/Accounts.js

@@ -15,11 +15,6 @@ export const Accounts = StripeResource.extend({
         method: 'POST',
         fullPath: '/v1/financial_connections/accounts/{account}/disconnect',
     }),
-    listInferredBalances: stripeMethod({
-        method: 'GET',
-        fullPath: '/v1/financial_connections/accounts/{account}/inferred_balances',
-        methodType: 'list',
-    }),
     listOwners: stripeMethod({
         method: 'GET',
         fullPath: '/v1/financial_connections/accounts/{account}/owners',

package/esm/resources/Invoices.js

@@ -15,14 +15,6 @@ export const Invoices = StripeResource.extend({
         method: 'POST',
         fullPath: '/v1/invoices/{invoice}/add_lines',
     }),
-    attachPayment: stripeMethod({
-        method: 'POST',
-        fullPath: '/v1/invoices/{invoice}/attach_payment',
-    }),
-    attachPaymentIntent: stripeMethod({
-        method: 'POST',
-        fullPath: '/v1/invoices/{invoice}/attach_payment_intent',
-    }),
     createPreview: stripeMethod({
         method: 'POST',
         fullPath: '/v1/invoices/create_preview',
@@ -36,11 +28,6 @@ export const Invoices = StripeResource.extend({
         fullPath: '/v1/invoices/{invoice}/lines',
         methodType: 'list',
     }),
-    listPayments: stripeMethod({
-        method: 'GET',
-        fullPath: '/v1/invoices/{invoice}/payments',
-        methodType: 'list',
-    }),
     listUpcomingLines: stripeMethod({
         method: 'GET',
         fullPath: '/v1/invoices/upcoming/lines',
@@ -55,10 +42,6 @@ export const Invoices = StripeResource.extend({
         method: 'POST',
         fullPath: '/v1/invoices/{invoice}/remove_lines',
     }),
-    retrievePayment: stripeMethod({
-        method: 'GET',
-        fullPath: '/v1/invoices/{invoice}/payments/{invoice_payment}',
-    }),
     retrieveUpcoming: stripeMethod({
         method: 'GET',
         fullPath: '/v1/invoices/upcoming',

package/esm/resources/PaymentIntents.js

@@ -32,10 +32,6 @@ export const PaymentIntents = StripeResource.extend({
         method: 'POST',
         fullPath: '/v1/payment_intents/{intent}/confirm',
     }),
-    decrementAuthorization: stripeMethod({
-        method: 'POST',
-        fullPath: '/v1/payment_intents/{intent}/decrement_authorization',
-    }),
     incrementAuthorization: stripeMethod({
         method: 'POST',
         fullPath: '/v1/payment_intents/{intent}/increment_authorization',