@ominity/api-typescript 1.4.8 → 1.6.0

package/src/funcs/commerce/customerSubscriptions.ts

@@ -10,3 +10,9 @@ export const customerSubscriptionsDelete = (client: ClientSDK, request: operatio
 export const customerSubscriptionsRenew = (client: ClientSDK, request: operations.RenewCustomerSubscriptionRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.renew", method: "POST", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.id}/renew`, requestSchema: operations.RenewCustomerSubscriptionRequest$outboundSchema, responseSchema: operations.RenewCustomerSubscriptionResponse$inboundSchema, query: encodeOperationQuery }, options);
 export const customerSubscriptionsListTransitionProducts = (client: ClientSDK, request: operations.ListCustomerSubscriptionTransitionProductsRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.listTransitionProducts", method: "GET", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/transition`, requestSchema: operations.ListCustomerSubscriptionTransitionProductsRequest$outboundSchema, responseSchema: operations.ListCustomerSubscriptionTransitionProductsResponse$inboundSchema, query: encodeOperationQuery }, options);
 export const customerSubscriptionsGetTransitionProduct = (client: ClientSDK, request: operations.GetCustomerSubscriptionTransitionProductRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.getTransitionProduct", method: "GET", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/transition/${v.productId}`, requestSchema: operations.GetCustomerSubscriptionTransitionProductRequest$outboundSchema, responseSchema: operations.GetCustomerSubscriptionTransitionProductResponse$inboundSchema, query: encodeOperationQuery }, options);
+export const customerSubscriptionsListTransitions = (client: ClientSDK, request: operations.ListCustomerSubscriptionTransitionsRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.listTransitions", method: "GET", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/transitions`, requestSchema: operations.ListCustomerSubscriptionTransitionsRequest$outboundSchema, responseSchema: operations.ListCustomerSubscriptionTransitionsResponse$inboundSchema }, options);
+export const customerSubscriptionsQuoteChange = (client: ClientSDK, request: operations.QuoteCustomerSubscriptionChangeRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.quoteChange", method: "POST", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/changes/quote`, requestSchema: operations.QuoteCustomerSubscriptionChangeRequest$outboundSchema, responseSchema: operations.QuoteCustomerSubscriptionChangeResponse$inboundSchema, body: (v) => v.data }, options);
+export const customerSubscriptionsConfirmChange = (client: ClientSDK, request: operations.ConfirmCustomerSubscriptionChangeRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.confirmChange", method: "POST", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/changes`, requestSchema: operations.ConfirmCustomerSubscriptionChangeRequest$outboundSchema, responseSchema: operations.ConfirmCustomerSubscriptionChangeResponse$inboundSchema, body: (v) => v.data }, options);
+export const customerSubscriptionsCancelChange = (client: ClientSDK, request: operations.CancelCustomerSubscriptionChangeRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.cancelChange", method: "DELETE", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/changes/${encodeURIComponent(v.changeId)}`, requestSchema: operations.CancelCustomerSubscriptionChangeRequest$outboundSchema, responseSchema: operations.CancelCustomerSubscriptionChangeResponse$inboundSchema, responseType: "void", successStatus: 204 }, options);
+export const customerSubscriptionsCancel = (client: ClientSDK, request: operations.CancelCustomerSubscriptionRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.cancel", method: "POST", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/cancellation`, requestSchema: operations.CancelCustomerSubscriptionRequest$outboundSchema, responseSchema: operations.CancelCustomerSubscriptionResponse$inboundSchema, body: (v) => v.data ?? {} }, options);
+export const customerSubscriptionsRevokeCancellation = (client: ClientSDK, request: operations.RevokeCustomerSubscriptionCancellationRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "commerce.customerSubscriptions.revokeCancellation", method: "DELETE", path: (v) => `/commerce/customers/${v.customerId}/subscriptions/${v.subscriptionId}/cancellation`, requestSchema: operations.RevokeCustomerSubscriptionCancellationRequest$outboundSchema, responseSchema: operations.RevokeCustomerSubscriptionCancellationResponse$inboundSchema, responseType: "void", successStatus: 204 }, options);

package/src/lib/config.ts

@@ -75,7 +75,7 @@ function applyApiVersion(url: URL, apiVersion: string | undefined): URL {
   return url;
 }
 
-export const SDK_VERSION = "1.4.8";
+export const SDK_VERSION = "1.6.0";
 
 export const SDK_METADATA = {
   language: "typescript",

package/src/models/commerce/cart-item.ts

@@ -1,33 +1,48 @@
 import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Product, Product$inboundSchema } from "./product.js";
 
-
-// Placeholder - waiting for actual data structure from user
 export type CartItem = {
-  id?: string;
-  [key: string]: any;
+  resource: "cartitem";
+  id: string;
+  cartId: string;
+  productId: number;
+  productOfferId: number | null;
+  quantity: number;
+  unitAmount: CurrencyAmount;
+  discountAmount: CurrencyAmount;
+  taxAmount: CurrencyAmount;
+  totalAmount: CurrencyAmount;
+  isShippingRequired: boolean;
+  updatedAt: string;
+  createdAt: string;
+  /** Present when requested with `include: "product"`. */
+  product?: Product;
+  links?: HalLinks;
 };
 
 /** @internal */
-export const CartItem$inboundSchema: z.ZodType<CartItem> = z
-  .object({
-    id: z.string().optional(),
-  })
-  .passthrough() as unknown as z.ZodType<CartItem>;
-
-/** @internal */
-export const CartItem$outboundSchema: z.ZodType<CartItem> = z
-  .object({
-    id: z.string().optional(),
-  })
-  .passthrough() as unknown as z.ZodType<CartItem>;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace CartItem$ {
-  /** @deprecated use `CartItem$inboundSchema` instead. */
-  export const inboundSchema = CartItem$inboundSchema;
-  /** @deprecated use `CartItem$outboundSchema` instead. */
-  export const outboundSchema = CartItem$outboundSchema;
-}
+export const CartItem$inboundSchema: z.ZodType<CartItem> = z.object({
+  resource: z.literal("cartitem"),
+  id: z.string(),
+  cartId: z.string(),
+  productId: z.number().int(),
+  productOfferId: z.number().int().nullable(),
+  quantity: z.number(),
+  unitAmount: CurrencyAmount$inboundSchema,
+  discountAmount: CurrencyAmount$inboundSchema,
+  taxAmount: CurrencyAmount$inboundSchema,
+  totalAmount: CurrencyAmount$inboundSchema,
+  isShippingRequired: z.boolean(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _embedded: z.object({ product: Product$inboundSchema.optional() }).optional(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((value) => {
+  const { _embedded, ...rest } = value;
+  const item = remap$(rest, { _links: "links" }) as CartItem;
+  if (_embedded?.product) item.product = _embedded.product;
+  return item;
+});

package/src/models/commerce/index.ts

@@ -29,4 +29,5 @@ export * from "./customer-user-permission.js";
 export * from "./customer-group.js";
 export * from "./mandate.js";
 export * from "./subscription.js";
+export * from "./subscription-change.js";
 export * from "./shipping-class.js";

package/src/models/commerce/product.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { ProductOffer, ProductOffer$inboundSchema } from "./product-offer.js";
 
 export type ProductRoute = {
   resource: string;
@@ -57,6 +58,8 @@ export type Product = {
   stock: number | null;
   isBackorderAllowed: boolean;
   routes: Record<string, ProductRoute>;
+  /** Present when requested with `include: "offers"`. */
+  offers?: Array<ProductOffer>;
   measurements?: ProductMeasurements;
   reviews?: ProductReviews;
   searches: Array<string>;
@@ -127,6 +130,7 @@ export const Product$inboundSchema: z.ZodType<Product> = z.object({
   stock: z.number().nullable(),
   isBackorderAllowed: z.boolean(),
   routes: z.record(z.string(), ProductRoute$inboundSchema),
+  offers: z.array(ProductOffer$inboundSchema).optional(),
   measurements: ProductMeasurements$inboundSchema.optional(),
   reviews: ProductReviews$inboundSchema.optional(),
   searches: z.array(z.string()),

package/src/models/commerce/subscription-change.ts

@@ -0,0 +1,137 @@
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Product, Product$inboundSchema } from "./product.js";
+
+/** `change` for a plan change, `cancel` for a cancellation. */
+export type SubscriptionChangeType = "change" | "cancel" | (string & {});
+
+export type SubscriptionChangeStatus =
+  | "quoted"
+  | "pending"
+  | "awaiting_payment"
+  | "applied"
+  | "cancelled"
+  | "expired"
+  | "failed"
+  | (string & {});
+
+export type SubscriptionChangeTiming = "immediate" | "period_end" | (string & {});
+
+/** The plan on one side of a change. */
+export type SubscriptionChangePlan = {
+  productId: number | null;
+  offerId: number | null;
+  intervalId: number | null;
+  recurringAmount: CurrencyAmount | null;
+  quantity: number | null;
+};
+
+export type SubscriptionChangeQuoteLine = {
+  type: string | null;
+  description: string | null;
+  amount: CurrencyAmount;
+  tax: CurrencyAmount;
+  taxRate: number | null;
+};
+
+export type SubscriptionChangeQuote = {
+  lines: SubscriptionChangeQuoteLine[];
+  charge: CurrencyAmount;
+  credit: CurrencyAmount;
+  settlement: string | null;
+};
+
+/** A quoted, scheduled or applied plan change or cancellation. */
+export type SubscriptionChange = {
+  resource: "subscription_change";
+  id: string;
+  subscriptionId: number;
+  type: SubscriptionChangeType;
+  direction: string | null;
+  status: SubscriptionChangeStatus;
+  timing: SubscriptionChangeTiming | null;
+  effectiveAt: string | null;
+  from: SubscriptionChangePlan;
+  to: SubscriptionChangePlan;
+  quote: SubscriptionChangeQuote;
+  warnings: string[];
+  quoteExpiresAt: string | null;
+  /** The order to pay for an immediate upgrade; also linked as `links.checkout`. */
+  orderId: number | null;
+  createdAt: string | null;
+  links?: HalLinks;
+};
+
+/** A plan the customer may change the subscription to, quoted at the default timing. */
+export type SubscriptionTransition = {
+  productId: number;
+  offerId: number;
+  direction: string | null;
+  timing: SubscriptionChangeTiming | null;
+  effectiveAt: string | null;
+  allowed: boolean;
+  reasons: string[];
+  charge: CurrencyAmount;
+  product: Product;
+};
+
+/** @internal */
+export const SubscriptionChangePlan$inboundSchema: z.ZodType<SubscriptionChangePlan> = z.object({
+  productId: z.number().int().nullable(),
+  offerId: z.number().int().nullable(),
+  intervalId: z.number().int().nullable(),
+  recurringAmount: CurrencyAmount$inboundSchema.nullable(),
+  quantity: z.number().int().nullable(),
+});
+
+/** @internal */
+export const SubscriptionChangeQuoteLine$inboundSchema: z.ZodType<SubscriptionChangeQuoteLine> = z.object({
+  type: z.string().nullable(),
+  description: z.string().nullable(),
+  amount: CurrencyAmount$inboundSchema,
+  tax: CurrencyAmount$inboundSchema,
+  taxRate: z.number().nullable(),
+});
+
+/** @internal */
+export const SubscriptionChangeQuote$inboundSchema: z.ZodType<SubscriptionChangeQuote> = z.object({
+  lines: z.array(SubscriptionChangeQuoteLine$inboundSchema),
+  charge: CurrencyAmount$inboundSchema,
+  credit: CurrencyAmount$inboundSchema,
+  settlement: z.string().nullable(),
+});
+
+/** @internal */
+export const SubscriptionChange$inboundSchema: z.ZodType<SubscriptionChange> = z.object({
+  resource: z.literal("subscription_change"),
+  id: z.string(),
+  subscriptionId: z.number().int(),
+  type: z.string(),
+  direction: z.string().nullable(),
+  status: z.string(),
+  timing: z.string().nullable(),
+  effectiveAt: z.string().nullable(),
+  from: SubscriptionChangePlan$inboundSchema,
+  to: SubscriptionChangePlan$inboundSchema,
+  quote: SubscriptionChangeQuote$inboundSchema,
+  warnings: z.array(z.string()),
+  quoteExpiresAt: z.string().nullable(),
+  orderId: z.number().int().nullable(),
+  createdAt: z.string().nullable(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((value) => remap$(value, { _links: "links" }) as SubscriptionChange);
+
+/** @internal */
+export const SubscriptionTransition$inboundSchema: z.ZodType<SubscriptionTransition> = z.object({
+  productId: z.number().int(),
+  offerId: z.number().int(),
+  direction: z.string().nullable(),
+  timing: z.string().nullable(),
+  effectiveAt: z.string().nullable(),
+  allowed: z.boolean(),
+  reasons: z.array(z.string()),
+  charge: CurrencyAmount$inboundSchema,
+  product: Product$inboundSchema,
+}).loose();

package/src/models/commerce/subscription.ts

@@ -14,6 +14,8 @@ export type SubscriptionPeriod = {
 export type Subscription = {
   resource: "subscription";
   id: number;
+  /** Readable reference; its format is configured per install. */
+  reference?: string | null | undefined;
   customerId: number;
   productId: number;
   intervalId: number;
@@ -42,6 +44,7 @@ export const SubscriptionPeriod$inboundSchema: z.ZodType<SubscriptionPeriod> = z
 export const Subscription$inboundSchema: z.ZodType<Subscription> = z.object({
   resource: z.literal("subscription"),
   id: z.number().int(),
+  reference: z.string().nullable().optional(),
   customerId: z.number().int(),
   productId: z.number().int(),
   intervalId: z.number().int(),

package/src/models/errors/error-response.ts

@@ -29,6 +29,10 @@ export type ErrorResponseData = {
    * A detailed human-readable description of the error that occurred.
    */
   detail: string;
+  /**
+   * Stable, machine-readable reason of a refusal, e.g. `subscription.next_period_locked`.
+   */
+  code?: string | undefined;
   /**
    * Optional validation errors keyed by field name.
    */
@@ -43,6 +47,7 @@ export class ErrorResponse extends OminityError {
   status: number;
   title: string;
   detail: string;
+  code?: string | undefined;
   fields?: Record<string, string[]> | undefined;
   links: ErrorResponseLinks;
 
@@ -61,6 +66,7 @@ export class ErrorResponse extends OminityError {
     this.status = err.status;
     this.title = err.title;
     this.detail = err.detail;
+    if (err.code != null) this.code = err.code;
     if (err.fields != null) this.fields = err.fields;
     this.links = err.links;
 
@@ -78,13 +84,17 @@ export const ErrorResponse$inboundSchema: z.ZodType<
   status: types.number(),
   title: types.string(),
   detail: types.string(),
+  code: z.optional(z.string()),
   fields: z.optional(ErrorResponseFieldsSchema),
+  errors: z.optional(ErrorResponseFieldsSchema),
   _links: z.lazy(() => ErrorResponseLinks$inboundSchema),
   request$: z.custom<Request>(x => x instanceof Request),
   response$: z.custom<Response>(x => x instanceof Response),
   body$: z.string(),
 }).transform((v) => {
-  const remapped = remap$(v, {
+  // The API sends validation messages as `errors`.
+  const { errors, ...rest } = v;
+  const remapped = remap$({ ...rest, fields: rest.fields ?? errors }, {
     "_links": "links",
   });
 
@@ -100,6 +110,7 @@ export type ErrorResponse$Outbound = {
   status: number;
   title: string;
   detail: string;
+  code?: string | undefined;
   fields?: Record<string, string[]> | undefined;
   _links: ErrorResponseLinks$Outbound;
 };
@@ -115,6 +126,7 @@ export const ErrorResponse$outboundSchema: z.ZodType<
       status: data.status,
       title: data.title,
       detail: data.detail,
+      code: data.code,
       fields: data.fields,
       _links: data.links,
     };

package/src/models/operations/commerce-customer-subscriptions.ts

@@ -1,6 +1,7 @@
 import * as z from "zod/v4";
 import { Product, Product$inboundSchema } from "../commerce/product.js";
 import { Subscription, Subscription$inboundSchema } from "../commerce/subscription.js";
+import { SubscriptionChange, SubscriptionChange$inboundSchema, SubscriptionTransition, SubscriptionTransition$inboundSchema } from "../commerce/subscription-change.js";
 import { Paginated } from "../pagination.js";
 import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
 
@@ -34,12 +35,48 @@ export type RenewCustomerSubscriptionResponse = Subscription;
 export const RenewCustomerSubscriptionRequest$outboundSchema: z.ZodType<RenewCustomerSubscriptionRequest> = GetCustomerSubscriptionRequest$outboundSchema;
 export const RenewCustomerSubscriptionResponse$inboundSchema = Subscription$inboundSchema;
 
+/** @deprecated Use `ListCustomerSubscriptionTransitionsRequest` (`GET .../transitions`). */
 export type ListCustomerSubscriptionTransitionProductsRequest = ListRequest & { customerId: number; subscriptionId: number };
 export type ListCustomerSubscriptionTransitionProductsResponse = Paginated<Product>;
 export const ListCustomerSubscriptionTransitionProductsRequest$outboundSchema: z.ZodType<ListCustomerSubscriptionTransitionProductsRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int(), subscriptionId: z.number().int() });
 export const ListCustomerSubscriptionTransitionProductsResponse$inboundSchema = paginatedSchema("products", Product$inboundSchema);
 
+/** @deprecated Use `QuoteCustomerSubscriptionChangeRequest` (`POST .../changes/quote`). */
 export type GetCustomerSubscriptionTransitionProductRequest = { customerId: number; subscriptionId: number; productId: number; include?: string | undefined };
 export type GetCustomerSubscriptionTransitionProductResponse = Product;
 export const GetCustomerSubscriptionTransitionProductRequest$outboundSchema: z.ZodType<GetCustomerSubscriptionTransitionProductRequest> = z.object({ customerId: z.number().int(), subscriptionId: z.number().int(), productId: z.number().int(), include: z.string().optional() });
 export const GetCustomerSubscriptionTransitionProductResponse$inboundSchema = Product$inboundSchema;
+
+export type ListCustomerSubscriptionTransitionsRequest = { customerId: number; subscriptionId: number };
+export type ListCustomerSubscriptionTransitionsResponse = { count: number; items: SubscriptionTransition[] };
+export const ListCustomerSubscriptionTransitionsRequest$outboundSchema: z.ZodType<ListCustomerSubscriptionTransitionsRequest> = z.object({ customerId: z.number().int(), subscriptionId: z.number().int() });
+export const ListCustomerSubscriptionTransitionsResponse$inboundSchema: z.ZodType<ListCustomerSubscriptionTransitionsResponse> = z.object({
+  count: z.number().int(),
+  _embedded: z.object({ transitions: z.array(SubscriptionTransition$inboundSchema) }),
+}).transform((value) => ({ count: value.count, items: value._embedded.transitions }));
+
+export type QuoteCustomerSubscriptionChangeRequest = { customerId: number; subscriptionId: number; data: { toOfferId: number; timing?: "immediate" | "period_end" | undefined } };
+export type QuoteCustomerSubscriptionChangeResponse = SubscriptionChange;
+export const QuoteCustomerSubscriptionChangeRequest$outboundSchema: z.ZodType<QuoteCustomerSubscriptionChangeRequest> = z.object({ customerId: z.number().int(), subscriptionId: z.number().int(), data: z.object({ toOfferId: z.number().int(), timing: z.enum(["immediate", "period_end"]).optional() }) });
+export const QuoteCustomerSubscriptionChangeResponse$inboundSchema = SubscriptionChange$inboundSchema;
+
+export type ConfirmCustomerSubscriptionChangeRequest = { customerId: number; subscriptionId: number; data: { quoteId: string } };
+export type ConfirmCustomerSubscriptionChangeResponse = SubscriptionChange;
+export const ConfirmCustomerSubscriptionChangeRequest$outboundSchema: z.ZodType<ConfirmCustomerSubscriptionChangeRequest> = z.object({ customerId: z.number().int(), subscriptionId: z.number().int(), data: z.object({ quoteId: z.string() }) });
+export const ConfirmCustomerSubscriptionChangeResponse$inboundSchema = SubscriptionChange$inboundSchema;
+
+export type CancelCustomerSubscriptionChangeRequest = { customerId: number; subscriptionId: number; changeId: string };
+export type CancelCustomerSubscriptionChangeResponse = void;
+export const CancelCustomerSubscriptionChangeRequest$outboundSchema: z.ZodType<CancelCustomerSubscriptionChangeRequest> = z.object({ customerId: z.number().int(), subscriptionId: z.number().int(), changeId: z.string() });
+export const CancelCustomerSubscriptionChangeResponse$inboundSchema: z.ZodType<void> = z.void();
+
+/** Without `quoteId` the cancellation is quoted; with the `id` of that quote it is confirmed. */
+export type CancelCustomerSubscriptionRequest = { customerId: number; subscriptionId: number; data?: { quoteId?: string | undefined; timing?: "immediate" | "period_end" | undefined } | undefined };
+export type CancelCustomerSubscriptionResponse = SubscriptionChange;
+export const CancelCustomerSubscriptionRequest$outboundSchema: z.ZodType<CancelCustomerSubscriptionRequest> = z.object({ customerId: z.number().int(), subscriptionId: z.number().int(), data: z.object({ quoteId: z.string().optional(), timing: z.enum(["immediate", "period_end"]).optional() }).optional() });
+export const CancelCustomerSubscriptionResponse$inboundSchema = SubscriptionChange$inboundSchema;
+
+export type RevokeCustomerSubscriptionCancellationRequest = { customerId: number; subscriptionId: number };
+export type RevokeCustomerSubscriptionCancellationResponse = void;
+export const RevokeCustomerSubscriptionCancellationRequest$outboundSchema: z.ZodType<RevokeCustomerSubscriptionCancellationRequest> = z.object({ customerId: z.number().int(), subscriptionId: z.number().int() });
+export const RevokeCustomerSubscriptionCancellationResponse$inboundSchema: z.ZodType<void> = z.void();

package/src/sdk/commerce/customer-subscriptions.ts

@@ -1,4 +1,4 @@
-import { customerSubscriptionsCreate, customerSubscriptionsDelete, customerSubscriptionsGet, customerSubscriptionsGetTransitionProduct, customerSubscriptionsList, customerSubscriptionsListTransitionProducts, customerSubscriptionsRenew, customerSubscriptionsUpdate } from "../../funcs/commerce/index.js";
+import { customerSubscriptionsCancel, customerSubscriptionsCancelChange, customerSubscriptionsConfirmChange, customerSubscriptionsCreate, customerSubscriptionsDelete, customerSubscriptionsGet, customerSubscriptionsGetTransitionProduct, customerSubscriptionsList, customerSubscriptionsListTransitionProducts, customerSubscriptionsListTransitions, customerSubscriptionsQuoteChange, customerSubscriptionsRenew, customerSubscriptionsRevokeCancellation, customerSubscriptionsUpdate } from "../../funcs/commerce/index.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -7,8 +7,23 @@ export class CustomerSubscriptions extends ClientSDK {
   async get(request: operations.GetCustomerSubscriptionRequest, options?: RequestOptions): Promise<operations.GetCustomerSubscriptionResponse> { return unwrapAsync(customerSubscriptionsGet(this, request, options)); }
   async create(request: operations.CreateCustomerSubscriptionRequest, options?: RequestOptions): Promise<operations.CreateCustomerSubscriptionResponse> { return unwrapAsync(customerSubscriptionsCreate(this, request, options)); }
   async update(request: operations.UpdateCustomerSubscriptionRequest, options?: RequestOptions): Promise<operations.UpdateCustomerSubscriptionResponse> { return unwrapAsync(customerSubscriptionsUpdate(this, request, options)); }
+  /** Cancels the subscription straight away. Use `cancel` to cancel according to the cancellation policy (notice, minimum term, period end). */
   async delete(request: operations.DeleteCustomerSubscriptionRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(customerSubscriptionsDelete(this, request, options)); }
   async renew(request: operations.RenewCustomerSubscriptionRequest, options?: RequestOptions): Promise<operations.RenewCustomerSubscriptionResponse> { return unwrapAsync(customerSubscriptionsRenew(this, request, options)); }
+  /** The plans the customer may change the subscription to, each quoted at the default timing. */
+  async listTransitions(request: operations.ListCustomerSubscriptionTransitionsRequest, options?: RequestOptions): Promise<operations.ListCustomerSubscriptionTransitionsResponse> { return unwrapAsync(customerSubscriptionsListTransitions(this, request, options)); }
+  /** Quotes a change to another offer. Confirm it with `confirmChange` before `quoteExpiresAt`. */
+  async quoteChange(request: operations.QuoteCustomerSubscriptionChangeRequest, options?: RequestOptions): Promise<operations.QuoteCustomerSubscriptionChangeResponse> { return unwrapAsync(customerSubscriptionsQuoteChange(this, request, options)); }
+  /** Confirms a quoted change. An immediate upgrade that needs payment returns the order to pay as `orderId` / `links.checkout`. */
+  async confirmChange(request: operations.ConfirmCustomerSubscriptionChangeRequest, options?: RequestOptions): Promise<operations.ConfirmCustomerSubscriptionChangeResponse> { return unwrapAsync(customerSubscriptionsConfirmChange(this, request, options)); }
+  /** Withdraws a scheduled change, or an immediate upgrade that was not paid yet. */
+  async cancelChange(request: operations.CancelCustomerSubscriptionChangeRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(customerSubscriptionsCancelChange(this, request, options)); }
+  /** Without `quoteId` quotes the cancellation; with the quote's `id` confirms it. It can be revoked until it takes effect. */
+  async cancel(request: operations.CancelCustomerSubscriptionRequest, options?: RequestOptions): Promise<operations.CancelCustomerSubscriptionResponse> { return unwrapAsync(customerSubscriptionsCancel(this, request, options)); }
+  /** Revokes a scheduled cancellation; the subscription keeps renewing. */
+  async revokeCancellation(request: operations.RevokeCustomerSubscriptionCancellationRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(customerSubscriptionsRevokeCancellation(this, request, options)); }
+  /** @deprecated Use `listTransitions`. The server may answer 410 Gone once the legacy endpoints are retired. */
   async listTransitionProducts(request: operations.ListCustomerSubscriptionTransitionProductsRequest, options?: RequestOptions): Promise<operations.ListCustomerSubscriptionTransitionProductsResponse> { return unwrapAsync(customerSubscriptionsListTransitionProducts(this, request, options)); }
+  /** @deprecated Use `quoteChange`. The server may answer 410 Gone once the legacy endpoints are retired. */
   async getTransitionProduct(request: operations.GetCustomerSubscriptionTransitionProductRequest, options?: RequestOptions): Promise<operations.GetCustomerSubscriptionTransitionProductResponse> { return unwrapAsync(customerSubscriptionsGetTransitionProduct(this, request, options)); }
 }