@ominity/api-typescript 1.4.2 → 1.4.4

package/src/models/operations/helpers.ts

@@ -0,0 +1,43 @@
+import * as z from "zod/v4";
+import { HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+
+export type ListRequest = {
+  include?: string | undefined;
+  filter?: Record<string, unknown> | undefined;
+  sort?: string | undefined;
+  page?: number | undefined;
+  limit?: number | undefined;
+};
+
+/** @internal */
+export const ListRequest$outboundSchema = z.object({
+  include: z.string().optional(),
+  filter: z.record(z.string(), z.unknown()).optional(),
+  sort: z.string().optional(),
+  page: z.number().int().positive().optional(),
+  limit: z.number().int().positive().max(250).optional(),
+});
+
+/** @internal */
+export function paginatedSchema<T>(
+  key: string,
+  itemSchema: z.ZodType<T>,
+): z.ZodType<Paginated<T>> {
+  return z.object({
+    _embedded: z.record(z.string(), z.unknown()),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+  }).transform((value, context) => {
+    const items = value._embedded[key];
+    const parsed = z.array(itemSchema).safeParse(items);
+    if (!parsed.success) {
+      context.addIssue({
+        code: "custom",
+        message: `Expected _embedded.${key} to contain an array`,
+      });
+      return z.NEVER;
+    }
+    return buildPaginated(parsed.data, value.count, value._links);
+  }) as z.ZodType<Paginated<T>>;
+}

package/src/models/operations/index.ts

@@ -40,3 +40,18 @@ export * from "./oauth2.js";
 export * from "./channels.js";
 export * from "./channel-types.js";
 export * from "./channel-domains.js";
+export * from "./commerce-customers.js";
+export * from "./commerce-customer-addresses.js";
+export * from "./commerce-customer-groups.js";
+export * from "./commerce-customer-mandates.js";
+export * from "./commerce-customer-payments.js";
+export * from "./commerce-customer-orders.js";
+export * from "./commerce-customer-invoices.js";
+export * from "./commerce-customer-subscriptions.js";
+export * from "./commerce-shipping-classes.js";
+export * from "./cms-routes.js";
+export * from "./settings-customer-groups.js";
+export * from "./settings-payment-method-issuers.js";
+export * from "./settings-languages.js";
+export * from "./media-library.js";
+export * from "./translations.js";

package/src/models/operations/media-library.ts

@@ -0,0 +1,64 @@
+import * as z from "zod/v4";
+import {
+  MediaFolder,
+  MediaFolder$inboundSchema,
+  MediaItem,
+  MediaItem$inboundSchema,
+  MediaList,
+  MediaList$inboundSchema,
+  PresignedMediaUpload,
+  PresignedMediaUpload$inboundSchema,
+} from "../media-library.js";
+
+export type MediaItemReference = { path: string; type: "file" | "folder" };
+export const MediaItemReference$outboundSchema = z.object({ path: z.string(), type: z.enum(["file", "folder"]) });
+
+export type ListMediaRequest = { path?: string | null | undefined };
+export type ListMediaResponse = MediaList;
+export const ListMediaRequest$outboundSchema: z.ZodType<ListMediaRequest> = z.object({ path: z.string().nullable().optional() });
+export const ListMediaResponse$inboundSchema = MediaList$inboundSchema;
+
+export type ListMediaFoldersRequest = ListMediaRequest;
+export type ListMediaFoldersResponse = Array<MediaFolder>;
+export const ListMediaFoldersRequest$outboundSchema: z.ZodType<ListMediaFoldersRequest> = ListMediaRequest$outboundSchema;
+export const ListMediaFoldersResponse$inboundSchema: z.ZodType<ListMediaFoldersResponse> = z.array(MediaFolder$inboundSchema);
+
+export type CreateMediaFolderRequest = { data: { name: string; parent?: string | null | undefined } };
+export type CreateMediaFolderResponse = MediaFolder;
+export const CreateMediaFolderRequest$outboundSchema: z.ZodType<CreateMediaFolderRequest> = z.object({ data: z.object({ name: z.string().max(255), parent: z.string().nullable().optional() }) });
+export const CreateMediaFolderResponse$inboundSchema = MediaFolder$inboundSchema;
+
+export type PresignMediaUploadRequest = { data: { filename: string; path?: string | null | undefined; mimeType: string; size: number; conflictStrategy?: "copy" | "override" | null | undefined; metadata?: Record<string, string | null> | null | undefined } };
+export type PresignMediaUploadResponse = PresignedMediaUpload;
+export const PresignMediaUploadRequest$outboundSchema: z.ZodType<PresignMediaUploadRequest> = z.object({ data: z.object({ filename: z.string().max(255), path: z.string().nullable().optional(), mimeType: z.string().max(255), size: z.number().int().positive(), conflictStrategy: z.enum(["copy", "override"]).nullable().optional(), metadata: z.record(z.string(), z.string().nullable()).nullable().optional() }) });
+export const PresignMediaUploadResponse$inboundSchema = PresignedMediaUpload$inboundSchema;
+
+export type DeleteMediaItemRequest = { data: MediaItemReference };
+export type DeleteMediaItemResponse = void;
+export const DeleteMediaItemRequest$outboundSchema: z.ZodType<DeleteMediaItemRequest> = z.object({ data: MediaItemReference$outboundSchema });
+export const DeleteMediaItemResponse$inboundSchema: z.ZodType<void> = z.void();
+
+export type MoveMediaItemRequest = { data: MediaItemReference & { targetPath: string } };
+export type MoveMediaItemResponse = void;
+export const MoveMediaItemRequest$outboundSchema: z.ZodType<MoveMediaItemRequest> = z.object({ data: MediaItemReference$outboundSchema.extend({ targetPath: z.string() }) });
+export const MoveMediaItemResponse$inboundSchema: z.ZodType<void> = z.void();
+
+export type RenameMediaItemRequest = { data: MediaItemReference & { newName: string } };
+export type RenameMediaItemResponse = { path: string };
+export const RenameMediaItemRequest$outboundSchema: z.ZodType<RenameMediaItemRequest> = z.object({ data: MediaItemReference$outboundSchema.extend({ newName: z.string().max(255) }) });
+export const RenameMediaItemResponse$inboundSchema: z.ZodType<RenameMediaItemResponse> = z.object({ path: z.string() });
+
+export type SearchMediaRequest = { q: string; path?: string | null | undefined };
+export type SearchMediaResponse = Array<MediaItem>;
+export const SearchMediaRequest$outboundSchema: z.ZodType<SearchMediaRequest> = z.object({ q: z.string().max(255), path: z.string().nullable().optional() });
+export const SearchMediaResponse$inboundSchema: z.ZodType<SearchMediaResponse> = z.array(MediaItem$inboundSchema);
+
+export type GetMediaSourceRequest = { path: string };
+export type GetMediaSourceResponse = Uint8Array;
+export const GetMediaSourceRequest$outboundSchema: z.ZodType<GetMediaSourceRequest> = z.object({ path: z.string() });
+export const GetMediaSourceResponse$inboundSchema: z.ZodType<Uint8Array> = z.instanceof(Uint8Array);
+
+export type DownloadMediaRequest = { data: { items: Array<MediaItemReference>; archive?: boolean | null | undefined } };
+export type DownloadMediaResponse = Uint8Array;
+export const DownloadMediaRequest$outboundSchema: z.ZodType<DownloadMediaRequest> = z.object({ data: z.object({ items: z.array(MediaItemReference$outboundSchema).min(1), archive: z.boolean().nullable().optional() }) });
+export const DownloadMediaResponse$inboundSchema: z.ZodType<Uint8Array> = z.instanceof(Uint8Array);

package/src/models/operations/settings-customer-groups.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { CustomerGroup, CustomerGroup$inboundSchema } from "../commerce/customer-group.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListSettingCustomerGroupsRequest = ListRequest;
+export type ListSettingCustomerGroupsResponse = Paginated<CustomerGroup>;
+export const ListSettingCustomerGroupsRequest$outboundSchema: z.ZodType<ListSettingCustomerGroupsRequest> = ListRequest$outboundSchema;
+export const ListSettingCustomerGroupsResponse$inboundSchema = paginatedSchema("customer_groups", CustomerGroup$inboundSchema);
+export type GetSettingCustomerGroupRequest = { id: number; include?: string | undefined };
+export type GetSettingCustomerGroupResponse = CustomerGroup;
+export const GetSettingCustomerGroupRequest$outboundSchema: z.ZodType<GetSettingCustomerGroupRequest> = z.object({ id: z.number().int(), include: z.string().optional() });
+export const GetSettingCustomerGroupResponse$inboundSchema = CustomerGroup$inboundSchema;

package/src/models/operations/settings-languages.ts

@@ -0,0 +1,9 @@
+import * as z from "zod/v4";
+import { ConfiguredLanguage, ConfiguredLanguage$inboundSchema } from "../settings/configured-language.js";
+import { Paginated } from "../pagination.js";
+import { paginatedSchema } from "./helpers.js";
+
+export type ListConfiguredLanguagesRequest = { filter?: { enabled?: boolean | undefined } | undefined };
+export type ListConfiguredLanguagesResponse = Paginated<ConfiguredLanguage>;
+export const ListConfiguredLanguagesRequest$outboundSchema: z.ZodType<ListConfiguredLanguagesRequest> = z.object({ filter: z.object({ enabled: z.boolean().optional() }).optional() });
+export const ListConfiguredLanguagesResponse$inboundSchema = paginatedSchema("languages", ConfiguredLanguage$inboundSchema);

package/src/models/operations/settings-payment-method-issuers.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { PaymentMethodIssuer, PaymentMethodIssuer$inboundSchema } from "../settings/payment-method-issuer.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListPaymentMethodIssuersRequest = ListRequest & { methodId: number };
+export type ListPaymentMethodIssuersResponse = Paginated<PaymentMethodIssuer>;
+export const ListPaymentMethodIssuersRequest$outboundSchema: z.ZodType<ListPaymentMethodIssuersRequest> = ListRequest$outboundSchema.extend({ methodId: z.number().int() });
+export const ListPaymentMethodIssuersResponse$inboundSchema = paginatedSchema("paymentmethod_issuers", PaymentMethodIssuer$inboundSchema);
+export type GetPaymentMethodIssuerRequest = { methodId: number; id: number };
+export type GetPaymentMethodIssuerResponse = PaymentMethodIssuer;
+export const GetPaymentMethodIssuerRequest$outboundSchema: z.ZodType<GetPaymentMethodIssuerRequest> = z.object({ methodId: z.number().int(), id: z.number().int() });
+export const GetPaymentMethodIssuerResponse$inboundSchema = PaymentMethodIssuer$inboundSchema;

package/src/models/operations/translations.ts

@@ -0,0 +1,9 @@
+import * as z from "zod/v4";
+
+export type TranslationField = { key: string; source?: string | null | undefined; current?: Record<string, string | null> | null | undefined };
+export type BulkTranslateRequest = { data: { source_language: string; target_languages: Array<string>; fields: Array<TranslationField>; override?: boolean | undefined; translate_empty_only?: boolean | undefined } };
+export type BulkTranslateResponse = { translations: Record<string, Record<string, string | null>>; skipped: Record<string, Record<string, string>> };
+export const BulkTranslateRequest$outboundSchema: z.ZodType<BulkTranslateRequest> = z.object({ data: z.object({
+  source_language: z.string(), target_languages: z.array(z.string()).min(1), fields: z.array(z.object({ key: z.string(), source: z.string().nullable().optional(), current: z.record(z.string(), z.string().nullable()).nullable().optional() })).min(1), override: z.boolean().optional(), translate_empty_only: z.boolean().optional(),
+}) });
+export const BulkTranslateResponse$inboundSchema: z.ZodType<BulkTranslateResponse> = z.object({ translations: z.record(z.string(), z.record(z.string(), z.string().nullable())), skipped: z.record(z.string(), z.record(z.string(), z.string())) });

package/src/models/settings/configured-language.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+
+export type ConfiguredLanguage = {
+  resource: "language";
+  code: string;
+  name: string;
+  native: string;
+  isDefault: boolean;
+  isEnabled: boolean;
+};
+
+/** @internal */
+export const ConfiguredLanguage$inboundSchema: z.ZodType<ConfiguredLanguage> = z.object({
+  resource: z.literal("language"),
+  code: z.string(),
+  name: z.string(),
+  native: z.string(),
+  isDefault: z.boolean(),
+  isEnabled: z.boolean(),
+});

package/src/models/settings/index.ts

@@ -2,3 +2,5 @@ export * from "./country.js";
 export * from "./social-provider.js";
 export * from "./social-provider-link.js";
 export * from "./payment-method.js";
+export * from "./payment-method-issuer.js";
+export * from "./configured-language.js";

package/src/models/settings/payment-method-issuer.ts

@@ -0,0 +1,30 @@
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type PaymentMethodIssuer = {
+  resource: "paymentmethod_issuer";
+  id: number;
+  paymentmethodId: number;
+  issuer: string;
+  name: string;
+  icon: string | null;
+  isEnabled: boolean;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const PaymentMethodIssuer$inboundSchema: z.ZodType<PaymentMethodIssuer> = z.object({
+  resource: z.literal("paymentmethod_issuer"),
+  id: z.number().int(),
+  paymentmethodId: z.number().int(),
+  issuer: z.string(),
+  name: z.string(),
+  icon: z.string().nullable(),
+  isEnabled: z.boolean(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => remap$(value, { _links: "links" }) as PaymentMethodIssuer);

package/src/sdk/cms/components.ts

@@ -4,6 +4,7 @@
 
 import { componentsList } from "../../funcs/cms/componentsList.js";
 import { componentsGet } from "../../funcs/cms/componentsGet.js";
+import { componentFieldsGet, componentFieldsList } from "../../funcs/cms/componentFields.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -22,4 +23,12 @@ export class Components extends ClientSDK {
     ): Promise<operations.GetComponentResponse> {
         return unwrapAsync(componentsGet(this, request, options));
     }
+
+    async listFields(request: operations.ListComponentFieldsRequest, options?: RequestOptions): Promise<operations.ListComponentFieldsResponse> {
+        return unwrapAsync(componentFieldsList(this, request, options));
+    }
+
+    async getField(request: operations.GetComponentFieldRequest, options?: RequestOptions): Promise<operations.GetComponentFieldResponse> {
+        return unwrapAsync(componentFieldsGet(this, request, options));
+    }
 }

package/src/sdk/cms/index.ts

@@ -9,6 +9,7 @@ import { ContentTypes } from "./content-types.js";
 import { Layouts } from "./layouts.js";
 import { Pages } from "./pages.js";
 import { Menus } from "./menus.js";
+import { Routes } from "./routes.js";
 
 export { Components } from "./components.js";
 export { Content } from "./content.js";
@@ -16,6 +17,7 @@ export { ContentTypes } from "./content-types.js";
 export { Layouts } from "./layouts.js";
 export { Pages } from "./pages.js";
 export { Menus } from "./menus.js";
+export { Routes } from "./routes.js";
 
 export class Cms extends ClientSDK {
     private _components?: Components;
@@ -24,6 +26,7 @@ export class Cms extends ClientSDK {
     private _layouts?: Layouts;
     private _pages?: Pages;
     private _menus?: Menus;
+    private _routes?: Routes;
 
     get components(): Components {
         return (this._components ??= new Components(this._options));
@@ -49,6 +52,8 @@ export class Cms extends ClientSDK {
         return (this._menus ??= new Menus(this._options));
     }
 
+    get routes(): Routes { return (this._routes ??= new Routes(this._options)); }
+
     protected override _propagateLanguage(language: string | undefined): void {
         this._components?.setLanguage(language);
         this._content?.setLanguage(language);
@@ -56,5 +61,6 @@ export class Cms extends ClientSDK {
         this._layouts?.setLanguage(language);
         this._pages?.setLanguage(language);
         this._menus?.setLanguage(language);
+        this._routes?.setLanguage(language);
     }
 }

package/src/sdk/cms/pages.ts

@@ -5,6 +5,7 @@
 import { pagesList } from "../../funcs/cms/pagesList.js";
 import { pagesGet } from "../../funcs/cms/pagesGet.js";
 import { pagesComponentsList } from "../../funcs/cms/pagesComponentsList.js";
+import { pageComponentFieldsGet, pageComponentsGet } from "../../funcs/cms/pageComponents.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -30,4 +31,12 @@ export class Pages extends ClientSDK {
     ): Promise<operations.ListPageComponentsResponse> {
         return unwrapAsync(pagesComponentsList(this, request, options));
     }
+
+    async getComponent(request: operations.GetPageComponentRequest, options?: RequestOptions): Promise<operations.GetPageComponentResponse> {
+        return unwrapAsync(pageComponentsGet(this, request, options));
+    }
+
+    async getComponentField(request: operations.GetPageComponentFieldRequest, options?: RequestOptions): Promise<operations.GetPageComponentFieldResponse> {
+        return unwrapAsync(pageComponentFieldsGet(this, request, options));
+    }
 }

package/src/sdk/cms/routes.ts

@@ -0,0 +1,8 @@
+import { cmsRoutesGet, cmsRoutesList } from "../../funcs/cms/routes.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+export class Routes extends ClientSDK {
+  async list(request: operations.ListCmsRoutesRequest = {}, options?: RequestOptions): Promise<operations.ListCmsRoutesResponse> { return unwrapAsync(cmsRoutesList(this, request, options)); }
+  async get(request: operations.GetCmsRouteRequest, options?: RequestOptions): Promise<operations.GetCmsRouteResponse> { return unwrapAsync(cmsRoutesGet(this, request, options)); }
+}

package/src/sdk/commerce/carts.ts

@@ -6,6 +6,7 @@ import { cartsList } from "../../funcs/commerce/cartsList.js";
 import { cartsCreate } from "../../funcs/commerce/cartsCreate.js";
 import { cartsGet } from "../../funcs/commerce/cartsGet.js";
 import { cartsUpdate } from "../../funcs/commerce/cartsUpdate.js";
+import { cartShippingMethodsList } from "../../funcs/commerce/cartShippingMethods.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -67,4 +68,8 @@ export class Carts extends ClientSDK {
       options,
     ));
   }
+
+  async listShippingMethods(request: operations.ListCartShippingMethodsRequest, options?: RequestOptions): Promise<operations.ListCartShippingMethodsResponse> {
+    return unwrapAsync(cartShippingMethodsList(this, request, options));
+  }
 }

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

@@ -0,0 +1,12 @@
+import { customerAddressesCreate, customerAddressesDelete, customerAddressesGet, customerAddressesList, customerAddressesUpdate } 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";
+
+export class CustomerAddresses extends ClientSDK {
+  async list(request: operations.ListCustomerAddressesRequest, options?: RequestOptions): Promise<operations.ListCustomerAddressesResponse> { return unwrapAsync(customerAddressesList(this, request, options)); }
+  async get(request: operations.GetCustomerAddressRequest, options?: RequestOptions): Promise<operations.GetCustomerAddressResponse> { return unwrapAsync(customerAddressesGet(this, request, options)); }
+  async create(request: operations.CreateCustomerAddressRequest, options?: RequestOptions): Promise<operations.CreateCustomerAddressResponse> { return unwrapAsync(customerAddressesCreate(this, request, options)); }
+  async update(request: operations.UpdateCustomerAddressRequest, options?: RequestOptions): Promise<operations.UpdateCustomerAddressResponse> { return unwrapAsync(customerAddressesUpdate(this, request, options)); }
+  async delete(request: operations.DeleteCustomerAddressRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(customerAddressesDelete(this, request, options)); }
+}

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

@@ -0,0 +1,8 @@
+import { customerGroupsGet, customerGroupsList } 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";
+export class CustomerGroups extends ClientSDK {
+  async list(request: operations.ListCustomerGroupsRequest, options?: RequestOptions): Promise<operations.ListCustomerGroupsResponse> { return unwrapAsync(customerGroupsList(this, request, options)); }
+  async get(request: operations.GetCustomerGroupRequest, options?: RequestOptions): Promise<operations.GetCustomerGroupResponse> { return unwrapAsync(customerGroupsGet(this, request, options)); }
+}

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

@@ -0,0 +1,9 @@
+import { customerInvoicesDownloadPdf, customerInvoicesGet, customerInvoicesList } 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";
+export class CustomerInvoices extends ClientSDK {
+  async list(request: operations.ListCustomerInvoicesRequest, options?: RequestOptions): Promise<operations.ListCustomerInvoicesResponse> { return unwrapAsync(customerInvoicesList(this, request, options)); }
+  async get(request: operations.GetCustomerInvoiceRequest, options?: RequestOptions): Promise<operations.GetCustomerInvoiceResponse> { return unwrapAsync(customerInvoicesGet(this, request, options)); }
+  async downloadPdf(request: operations.DownloadCustomerInvoicePdfRequest, options?: RequestOptions): Promise<Uint8Array> { return unwrapAsync(customerInvoicesDownloadPdf(this, request, options)); }
+}

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

@@ -0,0 +1,11 @@
+import { customerMandatesCreate, customerMandatesDelete, customerMandatesGet, customerMandatesList, customerMandatesUpdate } 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";
+export class CustomerMandates extends ClientSDK {
+  async list(request: operations.ListCustomerMandatesRequest, options?: RequestOptions): Promise<operations.ListCustomerMandatesResponse> { return unwrapAsync(customerMandatesList(this, request, options)); }
+  async get(request: operations.GetCustomerMandateRequest, options?: RequestOptions): Promise<operations.GetCustomerMandateResponse> { return unwrapAsync(customerMandatesGet(this, request, options)); }
+  async create(request: operations.CreateCustomerMandateRequest, options?: RequestOptions): Promise<operations.CreateCustomerMandateResponse> { return unwrapAsync(customerMandatesCreate(this, request, options)); }
+  async update(request: operations.UpdateCustomerMandateRequest, options?: RequestOptions): Promise<operations.UpdateCustomerMandateResponse> { return unwrapAsync(customerMandatesUpdate(this, request, options)); }
+  async delete(request: operations.DeleteCustomerMandateRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(customerMandatesDelete(this, request, options)); }
+}

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

@@ -0,0 +1,11 @@
+import { customerOrdersCreate, customerOrdersDelete, customerOrdersGet, customerOrdersList, customerOrdersUpdate } 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";
+export class CustomerOrders extends ClientSDK {
+  async list(request: operations.ListCustomerOrdersRequest, options?: RequestOptions): Promise<operations.ListCustomerOrdersResponse> { return unwrapAsync(customerOrdersList(this, request, options)); }
+  async get(request: operations.GetCustomerOrderRequest, options?: RequestOptions): Promise<operations.GetCustomerOrderResponse> { return unwrapAsync(customerOrdersGet(this, request, options)); }
+  async create(request: operations.CreateCustomerOrderRequest, options?: RequestOptions): Promise<operations.CreateCustomerOrderResponse> { return unwrapAsync(customerOrdersCreate(this, request, options)); }
+  async update(request: operations.UpdateCustomerOrderRequest, options?: RequestOptions): Promise<operations.UpdateCustomerOrderResponse> { return unwrapAsync(customerOrdersUpdate(this, request, options)); }
+  async delete(request: operations.DeleteCustomerOrderRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(customerOrdersDelete(this, request, options)); }
+}

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

@@ -0,0 +1,10 @@
+import { customerPaymentsCreate, customerPaymentsDelete, customerPaymentsGet, customerPaymentsList } 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";
+export class CustomerPayments extends ClientSDK {
+  async list(request: operations.ListCustomerPaymentsRequest, options?: RequestOptions): Promise<operations.ListCustomerPaymentsResponse> { return unwrapAsync(customerPaymentsList(this, request, options)); }
+  async get(request: operations.GetCustomerPaymentRequest, options?: RequestOptions): Promise<operations.GetCustomerPaymentResponse> { return unwrapAsync(customerPaymentsGet(this, request, options)); }
+  async create(request: operations.CreateCustomerPaymentRequest, options?: RequestOptions): Promise<operations.CreateCustomerPaymentResponse> { return unwrapAsync(customerPaymentsCreate(this, request, options)); }
+  async delete(request: operations.DeleteCustomerPaymentRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(customerPaymentsDelete(this, request, options)); }
+}

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

@@ -0,0 +1,14 @@
+import { customerSubscriptionsCreate, customerSubscriptionsDelete, customerSubscriptionsGet, customerSubscriptionsGetTransitionProduct, customerSubscriptionsList, customerSubscriptionsListTransitionProducts, customerSubscriptionsRenew, 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";
+export class CustomerSubscriptions extends ClientSDK {
+  async list(request: operations.ListCustomerSubscriptionsRequest, options?: RequestOptions): Promise<operations.ListCustomerSubscriptionsResponse> { return unwrapAsync(customerSubscriptionsList(this, request, options)); }
+  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)); }
+  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)); }
+  async listTransitionProducts(request: operations.ListCustomerSubscriptionTransitionProductsRequest, options?: RequestOptions): Promise<operations.ListCustomerSubscriptionTransitionProductsResponse> { return unwrapAsync(customerSubscriptionsListTransitionProducts(this, request, options)); }
+  async getTransitionProduct(request: operations.GetCustomerSubscriptionTransitionProductRequest, options?: RequestOptions): Promise<operations.GetCustomerSubscriptionTransitionProductResponse> { return unwrapAsync(customerSubscriptionsGetTransitionProduct(this, request, options)); }
+}

package/src/sdk/commerce/customers.ts

@@ -0,0 +1,11 @@
+import { customersCreate, customersGet, customersList, customersUpdate } 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";
+
+export class Customers extends ClientSDK {
+  async list(request: operations.ListCustomersRequest = {}, options?: RequestOptions): Promise<operations.ListCustomersResponse> { return unwrapAsync(customersList(this, request, options)); }
+  async get(request: operations.GetCustomerRequest, options?: RequestOptions): Promise<operations.GetCustomerResponse> { return unwrapAsync(customersGet(this, request, options)); }
+  async create(request: operations.CreateCustomerRequest, options?: RequestOptions): Promise<operations.CreateCustomerResponse> { return unwrapAsync(customersCreate(this, request, options)); }
+  async update(request: operations.UpdateCustomerRequest, options?: RequestOptions): Promise<operations.UpdateCustomerResponse> { return unwrapAsync(customersUpdate(this, request, options)); }
+}

package/src/sdk/commerce/index.ts

@@ -21,6 +21,15 @@ import { CustomerUsers } from "./customer-users.js";
 import { CustomerUserInvitations } from "./customer-user-invitations.js";
 import { CustomerUserRoles } from "./customer-user-roles.js";
 import { CustomerUserPermissions } from "./customer-user-permissions.js";
+import { Customers } from "./customers.js";
+import { CustomerAddresses } from "./customer-addresses.js";
+import { CustomerGroups } from "./customer-groups.js";
+import { CustomerMandates } from "./customer-mandates.js";
+import { CustomerPayments } from "./customer-payments.js";
+import { CustomerOrders } from "./customer-orders.js";
+import { CustomerInvoices } from "./customer-invoices.js";
+import { CustomerSubscriptions } from "./customer-subscriptions.js";
+import { ShippingClasses } from "./shipping-classes.js";
 
 export { CartItems } from "./cart-items.js";
 export { Carts } from "./carts.js";
@@ -40,6 +49,15 @@ export { CustomerUsers } from "./customer-users.js";
 export { CustomerUserInvitations } from "./customer-user-invitations.js";
 export { CustomerUserRoles } from "./customer-user-roles.js";
 export { CustomerUserPermissions } from "./customer-user-permissions.js";
+export { Customers } from "./customers.js";
+export { CustomerAddresses } from "./customer-addresses.js";
+export { CustomerGroups } from "./customer-groups.js";
+export { CustomerMandates } from "./customer-mandates.js";
+export { CustomerPayments } from "./customer-payments.js";
+export { CustomerOrders } from "./customer-orders.js";
+export { CustomerInvoices } from "./customer-invoices.js";
+export { CustomerSubscriptions } from "./customer-subscriptions.js";
+export { ShippingClasses } from "./shipping-classes.js";
 
 export class Commerce extends ClientSDK {
   private _cartItems?: CartItems;
@@ -60,6 +78,15 @@ export class Commerce extends ClientSDK {
   private _customerUserInvitations?: CustomerUserInvitations;
   private _customerUserRoles?: CustomerUserRoles;
   private _customerUserPermissions?: CustomerUserPermissions;
+  private _customers?: Customers;
+  private _customerAddresses?: CustomerAddresses;
+  private _customerGroups?: CustomerGroups;
+  private _customerMandates?: CustomerMandates;
+  private _customerPayments?: CustomerPayments;
+  private _customerOrders?: CustomerOrders;
+  private _customerInvoices?: CustomerInvoices;
+  private _customerSubscriptions?: CustomerSubscriptions;
+  private _shippingClasses?: ShippingClasses;
 
   get cartItems(): CartItems {
     return (this._cartItems ??= new CartItems(this._options));
@@ -133,6 +160,16 @@ export class Commerce extends ClientSDK {
     return (this._customerUserPermissions ??= new CustomerUserPermissions(this._options));
   }
 
+  get customers(): Customers { return (this._customers ??= new Customers(this._options)); }
+  get customerAddresses(): CustomerAddresses { return (this._customerAddresses ??= new CustomerAddresses(this._options)); }
+  get customerGroups(): CustomerGroups { return (this._customerGroups ??= new CustomerGroups(this._options)); }
+  get customerMandates(): CustomerMandates { return (this._customerMandates ??= new CustomerMandates(this._options)); }
+  get customerPayments(): CustomerPayments { return (this._customerPayments ??= new CustomerPayments(this._options)); }
+  get customerOrders(): CustomerOrders { return (this._customerOrders ??= new CustomerOrders(this._options)); }
+  get customerInvoices(): CustomerInvoices { return (this._customerInvoices ??= new CustomerInvoices(this._options)); }
+  get customerSubscriptions(): CustomerSubscriptions { return (this._customerSubscriptions ??= new CustomerSubscriptions(this._options)); }
+  get shippingClasses(): ShippingClasses { return (this._shippingClasses ??= new ShippingClasses(this._options)); }
+
   protected override _propagateLanguage(language: string | undefined): void {
     this._cartItems?.setLanguage(language);
     this._carts?.setLanguage(language);
@@ -152,5 +189,14 @@ export class Commerce extends ClientSDK {
     this._customerUserInvitations?.setLanguage(language);
     this._customerUserRoles?.setLanguage(language);
     this._customerUserPermissions?.setLanguage(language);
+    this._customers?.setLanguage(language);
+    this._customerAddresses?.setLanguage(language);
+    this._customerGroups?.setLanguage(language);
+    this._customerMandates?.setLanguage(language);
+    this._customerPayments?.setLanguage(language);
+    this._customerOrders?.setLanguage(language);
+    this._customerInvoices?.setLanguage(language);
+    this._customerSubscriptions?.setLanguage(language);
+    this._shippingClasses?.setLanguage(language);
   }
 }

package/src/sdk/commerce/invoices.ts

@@ -4,6 +4,7 @@
 
 import { invoicesGet } from "../../funcs/commerce/invoicesGet.js";
 import { invoicesList } from "../../funcs/commerce/invoicesList.js";
+import { invoicesCreate, invoicesDownloadPdf, invoicesUpdate } from "../../funcs/commerce/invoicesMutations.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -36,4 +37,16 @@ export class Invoices extends ClientSDK {
             options,
         ));
     }
+
+    async create(request: operations.CreateInvoiceRequest, options?: RequestOptions): Promise<operations.CreateInvoiceResponse> {
+        return unwrapAsync(invoicesCreate(this, request, options));
+    }
+
+    async update(request: operations.UpdateInvoiceRequest, options?: RequestOptions): Promise<operations.UpdateInvoiceResponse> {
+        return unwrapAsync(invoicesUpdate(this, request, options));
+    }
+
+    async downloadPdf(request: operations.DownloadInvoicePdfRequest, options?: RequestOptions): Promise<Uint8Array> {
+        return unwrapAsync(invoicesDownloadPdf(this, request, options));
+    }
 }

package/src/sdk/commerce/orders.ts

@@ -7,6 +7,7 @@ import { ordersCreate } from "../../funcs/commerce/ordersCreate.js";
 import { ordersGet } from "../../funcs/commerce/ordersGet.js";
 import { ordersUpdate } from "../../funcs/commerce/ordersUpdate.js";
 import { ordersPaymentsList } from "../../funcs/commerce/ordersPaymentsList.js";
+import { orderPaymentsCreate, orderPaymentsGet } from "../../funcs/commerce/paymentsMutations.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -83,4 +84,12 @@ export class Orders extends ClientSDK {
             options,
         ));
     }
+
+    async createPayment(request: operations.CreateOrderPaymentRequest, options?: RequestOptions): Promise<operations.CreateOrderPaymentResponse> {
+        return unwrapAsync(orderPaymentsCreate(this, request, options));
+    }
+
+    async getPayment(request: operations.GetOrderPaymentRequest, options?: RequestOptions): Promise<operations.GetOrderPaymentResponse> {
+        return unwrapAsync(orderPaymentsGet(this, request, options));
+    }
 }

package/src/sdk/commerce/payments.ts

@@ -3,11 +3,20 @@
  */
 
 import { paymentsGet } from "../../funcs/commerce/paymentsGet.js";
+import { paymentsCreate, paymentsList } from "../../funcs/commerce/paymentsMutations.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
 
 export class Payments extends ClientSDK {
+    async list(request: operations.ListPaymentsRequest = {}, options?: RequestOptions): Promise<operations.ListPaymentsResponse> {
+        return unwrapAsync(paymentsList(this, request, options));
+    }
+
+    async create(request: operations.CreatePaymentRequest, options?: RequestOptions): Promise<operations.CreatePaymentResponse> {
+        return unwrapAsync(paymentsCreate(this, request, options));
+    }
+
     /**
      * Get payment.
      */

package/src/sdk/commerce/products.ts

@@ -5,6 +5,7 @@
 import { productsList } from "../../funcs/commerce/productsList.js";
 import { productsGet } from "../../funcs/commerce/productsGet.js";
 import { productsOffersList } from "../../funcs/commerce/productsOffersList.js";
+import { productsOfferGet } from "../../funcs/commerce/productsOfferGet.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -30,4 +31,8 @@ export class Products extends ClientSDK {
   ): Promise<operations.ListProductOffersResponse> {
     return unwrapAsync(productsOffersList(this, request, options));
   }
+
+  async getOffer(request: operations.GetProductOfferRequest, options?: RequestOptions): Promise<operations.GetProductOfferResponse> {
+    return unwrapAsync(productsOfferGet(this, request, options));
+  }
 }