@revkeen/sdk 1.20260312.41

package/api/resources/subscriptions/client/Client.ts

@@ -0,0 +1,1293 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js";
+import { type NormalizedClientOptionsWithAuth, normalizeClientOptionsWithAuth } from "../../../../BaseClient.js";
+import { mergeHeaders } from "../../../../core/headers.js";
+import * as core from "../../../../core/index.js";
+import * as environments from "../../../../environments.js";
+import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js";
+import * as errors from "../../../../errors/index.js";
+import * as RevKeen from "../../../index.js";
+
+export declare namespace SubscriptionsClient {
+    export type Options = BaseClientOptions;
+
+    export interface RequestOptions extends BaseRequestOptions {}
+}
+
+/**
+ * Manage recurring billing. Create, update, pause, or cancel subscriptions.
+ *
+ * **Required Scopes:**
+ * - `subscriptions:read` - List and retrieve subscriptions
+ * - `subscriptions:write` - Create, update, cancel subscriptions
+ *
+ * **MCP Tools:** `subscriptions_get`
+ */
+export class SubscriptionsClient {
+    protected readonly _options: NormalizedClientOptionsWithAuth<SubscriptionsClient.Options>;
+
+    constructor(options: SubscriptionsClient.Options) {
+        this._options = normalizeClientOptionsWithAuth(options);
+    }
+
+    /**
+     * Retrieve a paginated list of subscriptions with optional filters
+     *
+     * @param {RevKeen.SubscriptionsListRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     *
+     * @example
+     *     await client.subscriptions.list()
+     */
+    public list(
+        request: RevKeen.SubscriptionsListRequest = {},
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionListResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
+    }
+
+    private async __list(
+        request: RevKeen.SubscriptionsListRequest = {},
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionListResponse>> {
+        const { page, limit, status, customerId } = request;
+        const _queryParams: Record<string, unknown> = {
+            page,
+            limit,
+            status: status != null ? status : undefined,
+            customerId,
+        };
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                "subscriptions",
+            ),
+            method: "GET",
+            headers: _headers,
+            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionListResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/subscriptions");
+    }
+
+    /**
+     * Create a new subscription for a customer
+     *
+     * @param {RevKeen.SubscriptionsCreateRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.BadRequestError}
+     * @throws {@link RevKeen.UnauthorizedError}
+     *
+     * @example
+     *     await client.subscriptions.create({
+     *         customerId: "customerId"
+     *     })
+     */
+    public create(
+        request: RevKeen.SubscriptionsCreateRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionCreateResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__create(request, requestOptions));
+    }
+
+    private async __create(
+        request: RevKeen.SubscriptionsCreateRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionCreateResponse>> {
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                "subscriptions",
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: request,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionCreateResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new RevKeen.BadRequestError(_response.error.body as unknown, _response.rawResponse);
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/subscriptions");
+    }
+
+    /**
+     * Retrieve detailed information about a specific subscription
+     *
+     * @param {RevKeen.SubscriptionsRetrieveRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.retrieve({
+     *         id: "id"
+     *     })
+     */
+    public retrieve(
+        request: RevKeen.SubscriptionsRetrieveRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionRetrieveResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__retrieve(request, requestOptions));
+    }
+
+    private async __retrieve(
+        request: RevKeen.SubscriptionsRetrieveRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionRetrieveResponse>> {
+        const { id } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}`,
+            ),
+            method: "GET",
+            headers: _headers,
+            queryParameters: requestOptions?.queryParams,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionRetrieveResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/subscriptions/{id}");
+    }
+
+    /**
+     * Cancel an active subscription immediately or at period end
+     *
+     * @param {RevKeen.SubscriptionsCancelRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.cancel({
+     *         id: "id"
+     *     })
+     */
+    public cancel(
+        request: RevKeen.SubscriptionsCancelRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionCancelResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__cancel(request, requestOptions));
+    }
+
+    private async __cancel(
+        request: RevKeen.SubscriptionsCancelRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionCancelResponse>> {
+        const { id } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}`,
+            ),
+            method: "DELETE",
+            headers: _headers,
+            queryParameters: requestOptions?.queryParams,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionCancelResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/subscriptions/{id}");
+    }
+
+    /**
+     * Update an existing subscription's properties
+     *
+     * @param {RevKeen.SubscriptionsUpdateRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.update({
+     *         id: "id"
+     *     })
+     */
+    public update(
+        request: RevKeen.SubscriptionsUpdateRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionUpdateResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__update(request, requestOptions));
+    }
+
+    private async __update(
+        request: RevKeen.SubscriptionsUpdateRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionUpdateResponse>> {
+        const { id, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}`,
+            ),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionUpdateResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/subscriptions/{id}");
+    }
+
+    /**
+     * Change the plan for an existing subscription with optional proration
+     *
+     * @param {RevKeen.SubscriptionsChangePlanRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.changeplan({
+     *         id: "id",
+     *         newPlanId: "newPlanId"
+     *     })
+     */
+    public changeplan(
+        request: RevKeen.SubscriptionsChangePlanRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionChangePlanResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__changeplan(request, requestOptions));
+    }
+
+    private async __changeplan(
+        request: RevKeen.SubscriptionsChangePlanRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionChangePlanResponse>> {
+        const { id, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}/change-plan`,
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionChangePlanResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/subscriptions/{id}/change-plan",
+        );
+    }
+
+    /**
+     * Update the quantity for a subscription with optional proration
+     *
+     * @param {RevKeen.SubscriptionsChangeQuantityRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.changequantity({
+     *         id: "id",
+     *         newQuantity: 1
+     *     })
+     */
+    public changequantity(
+        request: RevKeen.SubscriptionsChangeQuantityRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionChangeQuantityResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__changequantity(request, requestOptions));
+    }
+
+    private async __changequantity(
+        request: RevKeen.SubscriptionsChangeQuantityRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionChangeQuantityResponse>> {
+        const { id, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}/change-quantity`,
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionChangeQuantityResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/subscriptions/{id}/change-quantity",
+        );
+    }
+
+    /**
+     * Preview the upcoming renewal dates and amounts for an existing subscription.
+     *
+     * This uses the same billing calculation logic as the actual scheduler to show exactly when
+     * and how much the subscription will be billed (Key Invariant #4: Preview === Scheduler).
+     *
+     * @param {RevKeen.SubscriptionsPreviewRenewalRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.previewrenewal({
+     *         id: "id"
+     *     })
+     */
+    public previewrenewal(
+        request: RevKeen.SubscriptionsPreviewRenewalRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionPreviewRenewalResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__previewrenewal(request, requestOptions));
+    }
+
+    private async __previewrenewal(
+        request: RevKeen.SubscriptionsPreviewRenewalRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionPreviewRenewalResponse>> {
+        const { id, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}/preview-renewal`,
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionPreviewRenewalResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/subscriptions/{id}/preview-renewal",
+        );
+    }
+
+    /**
+     * Pause an active subscription. While paused:
+     * - No new invoices are generated
+     * - The subscription status changes to "paused"
+     * - The customer retains access until the current period ends (depending on your business logic)
+     *
+     * **Behavior Options:**
+     * - `keep_as_draft`: Invoices are created as drafts (default)
+     * - `mark_uncollectible`: Invoices are marked uncollectible
+     * - `void`: Invoices are voided
+     *
+     * Optionally set `resumes_at` to automatically resume at a future date.
+     *
+     * @param {RevKeen.PauseSubscriptionInput} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.BadRequestError}
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.pause({
+     *         id: "id"
+     *     })
+     */
+    public pause(
+        request: RevKeen.PauseSubscriptionInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionPauseResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__pause(request, requestOptions));
+    }
+
+    private async __pause(
+        request: RevKeen.PauseSubscriptionInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionPauseResponse>> {
+        const { id, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}/pause`,
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionPauseResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new RevKeen.BadRequestError(_response.error.body as unknown, _response.rawResponse);
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/subscriptions/{id}/pause");
+    }
+
+    /**
+     * Resume a paused subscription. The subscription status changes back to "active" and normal billing resumes.
+     *
+     * If the subscription was paused with draft invoices, you may need to manually finalize and send them.
+     *
+     * @param {RevKeen.SubscriptionsResumeRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.BadRequestError}
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.resume({
+     *         id: "id"
+     *     })
+     */
+    public resume(
+        request: RevKeen.SubscriptionsResumeRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionResumeResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__resume(request, requestOptions));
+    }
+
+    private async __resume(
+        request: RevKeen.SubscriptionsResumeRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionResumeResponse>> {
+        const { id } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}/resume`,
+            ),
+            method: "POST",
+            headers: _headers,
+            queryParameters: requestOptions?.queryParams,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionResumeResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new RevKeen.BadRequestError(_response.error.body as unknown, _response.rawResponse);
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/subscriptions/{id}/resume");
+    }
+
+    /**
+     * Cancel a subscription either immediately or at the end of the current billing period.
+     *
+     * **Modes:**
+     * - `immediately`: Status set to "canceled", access revoked now
+     * - `period_end`: cancelAtPeriodEnd flag set, access continues until period end
+     *
+     * @param {RevKeen.CancelSubscriptionInput} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.BadRequestError}
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.cancelsubscription({
+     *         id: "id",
+     *         mode: "immediately"
+     *     })
+     */
+    public cancelsubscription(
+        request: RevKeen.CancelSubscriptionInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionCancelSubscriptionResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__cancelsubscription(request, requestOptions));
+    }
+
+    private async __cancelsubscription(
+        request: RevKeen.CancelSubscriptionInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionCancelSubscriptionResponse>> {
+        const { id, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}/cancel`,
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionCancelSubscriptionResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new RevKeen.BadRequestError(_response.error.body as unknown, _response.rawResponse);
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/subscriptions/{id}/cancel");
+    }
+
+    /**
+     * Reverse a scheduled cancellation. The subscription must be active with cancelAtPeriodEnd=true.
+     * Clears the cancellation flag and the subscription continues as normal.
+     *
+     * @param {RevKeen.SubscriptionsReactivateRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.BadRequestError}
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.reactivate({
+     *         id: "id"
+     *     })
+     */
+    public reactivate(
+        request: RevKeen.SubscriptionsReactivateRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionReactivateResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__reactivate(request, requestOptions));
+    }
+
+    private async __reactivate(
+        request: RevKeen.SubscriptionsReactivateRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionReactivateResponse>> {
+        const { id } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(id)}/reactivate`,
+            ),
+            method: "POST",
+            headers: _headers,
+            queryParameters: requestOptions?.queryParams,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionReactivateResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new RevKeen.BadRequestError(_response.error.body as unknown, _response.rawResponse);
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/subscriptions/{id}/reactivate",
+        );
+    }
+
+    /**
+     * Retrieve all line items for a specific subscription. Items represent individual products/prices within a multi-product subscription.
+     *
+     * @param {RevKeen.SubscriptionItemsListRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.subscriptionItemsList({
+     *         subscriptionId: "subscriptionId"
+     *     })
+     */
+    public subscriptionItemsList(
+        request: RevKeen.SubscriptionItemsListRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionItemListResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__subscriptionItemsList(request, requestOptions));
+    }
+
+    private async __subscriptionItemsList(
+        request: RevKeen.SubscriptionItemsListRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionItemListResponse>> {
+        const { subscriptionId, limit, offset } = request;
+        const _queryParams: Record<string, unknown> = {
+            limit,
+            offset,
+        };
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(subscriptionId)}/items`,
+            ),
+            method: "GET",
+            headers: _headers,
+            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body as RevKeen.SubscriptionItemListResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "GET",
+            "/subscriptions/{subscriptionId}/items",
+        );
+    }
+
+    /**
+     * Add a new line item to an existing subscription. This is used for multi-product subscriptions where items share the same billing interval.
+     *
+     * @param {RevKeen.CreateSubscriptionItemInput} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.BadRequestError}
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.subscriptionItemsCreate({
+     *         subscriptionId: "subscriptionId",
+     *         currency: "USD",
+     *         unit_amount_minor: 2999
+     *     })
+     */
+    public subscriptionItemsCreate(
+        request: RevKeen.CreateSubscriptionItemInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionItemCreateResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__subscriptionItemsCreate(request, requestOptions));
+    }
+
+    private async __subscriptionItemsCreate(
+        request: RevKeen.CreateSubscriptionItemInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionItemCreateResponse>> {
+        const { subscriptionId, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(subscriptionId)}/items`,
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionItemCreateResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new RevKeen.BadRequestError(_response.error.body as unknown, _response.rawResponse);
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/subscriptions/{subscriptionId}/items",
+        );
+    }
+
+    /**
+     * Remove a line item from a subscription. Cannot remove the last item - cancel the subscription instead.
+     *
+     * @param {RevKeen.SubscriptionItemsDeleteRequest} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.BadRequestError}
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.subscriptionItemsDelete({
+     *         subscriptionId: "subscriptionId",
+     *         itemId: "itemId"
+     *     })
+     */
+    public subscriptionItemsDelete(
+        request: RevKeen.SubscriptionItemsDeleteRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionItemDeleteResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__subscriptionItemsDelete(request, requestOptions));
+    }
+
+    private async __subscriptionItemsDelete(
+        request: RevKeen.SubscriptionItemsDeleteRequest,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionItemDeleteResponse>> {
+        const { subscriptionId, itemId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(subscriptionId)}/items/${core.url.encodePathParam(itemId)}`,
+            ),
+            method: "DELETE",
+            headers: _headers,
+            queryParameters: requestOptions?.queryParams,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionItemDeleteResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new RevKeen.BadRequestError(_response.error.body as unknown, _response.rawResponse);
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "DELETE",
+            "/subscriptions/{subscriptionId}/items/{itemId}",
+        );
+    }
+
+    /**
+     * Update a subscription item's quantity, description, price, or fulfillment type.
+     *
+     * @param {RevKeen.UpdateSubscriptionItemInput} request
+     * @param {SubscriptionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link RevKeen.UnauthorizedError}
+     * @throws {@link RevKeen.NotFoundError}
+     *
+     * @example
+     *     await client.subscriptions.subscriptionItemsUpdate({
+     *         subscriptionId: "subscriptionId",
+     *         itemId: "itemId"
+     *     })
+     */
+    public subscriptionItemsUpdate(
+        request: RevKeen.UpdateSubscriptionItemInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): core.HttpResponsePromise<RevKeen.SubscriptionItemUpdateResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__subscriptionItemsUpdate(request, requestOptions));
+    }
+
+    private async __subscriptionItemsUpdate(
+        request: RevKeen.UpdateSubscriptionItemInput,
+        requestOptions?: SubscriptionsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<RevKeen.SubscriptionItemUpdateResponse>> {
+        const { subscriptionId, itemId, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
+        );
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.RevKeenEnvironment.Default,
+                `subscriptions/${core.url.encodePathParam(subscriptionId)}/items/${core.url.encodePathParam(itemId)}`,
+            ),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body as RevKeen.SubscriptionItemUpdateResponse,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new RevKeen.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 404:
+                    throw new RevKeen.NotFoundError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.RevKeenError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "PATCH",
+            "/subscriptions/{subscriptionId}/items/{itemId}",
+        );
+    }
+}