@ominity/api-typescript 1.4.3 → 1.4.4

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));
+  }
 }

package/src/sdk/commerce/shipping-classes.ts

@@ -0,0 +1,8 @@
+import { shippingClassesGet, shippingClassesList } 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 ShippingClasses extends ClientSDK {
+  async list(request: operations.ListShippingClassesRequest = {}, options?: RequestOptions): Promise<operations.ListShippingClassesResponse> { return unwrapAsync(shippingClassesList(this, request, options)); }
+  async get(request: operations.GetShippingClassRequest, options?: RequestOptions): Promise<operations.GetShippingClassResponse> { return unwrapAsync(shippingClassesGet(this, request, options)); }
+}

package/src/sdk/media-library.ts

@@ -0,0 +1,28 @@
+import {
+  mediaLibraryDownload,
+  mediaLibraryFoldersCreate,
+  mediaLibraryFoldersList,
+  mediaLibraryItemsDelete,
+  mediaLibraryItemsMove,
+  mediaLibraryItemsRename,
+  mediaLibraryList,
+  mediaLibrarySearch,
+  mediaLibrarySource,
+  mediaLibraryUploadsPresign,
+} from "../funcs/mediaLibrary.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class MediaLibrary extends ClientSDK {
+  async list(request: operations.ListMediaRequest = {}, options?: RequestOptions): Promise<operations.ListMediaResponse> { return unwrapAsync(mediaLibraryList(this, request, options)); }
+  async listFolders(request: operations.ListMediaFoldersRequest = {}, options?: RequestOptions): Promise<operations.ListMediaFoldersResponse> { return unwrapAsync(mediaLibraryFoldersList(this, request, options)); }
+  async createFolder(request: operations.CreateMediaFolderRequest, options?: RequestOptions): Promise<operations.CreateMediaFolderResponse> { return unwrapAsync(mediaLibraryFoldersCreate(this, request, options)); }
+  async presignUpload(request: operations.PresignMediaUploadRequest, options?: RequestOptions): Promise<operations.PresignMediaUploadResponse> { return unwrapAsync(mediaLibraryUploadsPresign(this, request, options)); }
+  async deleteItem(request: operations.DeleteMediaItemRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(mediaLibraryItemsDelete(this, request, options)); }
+  async moveItem(request: operations.MoveMediaItemRequest, options?: RequestOptions): Promise<void> { return unwrapAsync(mediaLibraryItemsMove(this, request, options)); }
+  async renameItem(request: operations.RenameMediaItemRequest, options?: RequestOptions): Promise<operations.RenameMediaItemResponse> { return unwrapAsync(mediaLibraryItemsRename(this, request, options)); }
+  async search(request: operations.SearchMediaRequest, options?: RequestOptions): Promise<operations.SearchMediaResponse> { return unwrapAsync(mediaLibrarySearch(this, request, options)); }
+  async source(request: operations.GetMediaSourceRequest, options?: RequestOptions): Promise<Uint8Array> { return unwrapAsync(mediaLibrarySource(this, request, options)); }
+  async download(request: operations.DownloadMediaRequest, options?: RequestOptions): Promise<Uint8Array> { return unwrapAsync(mediaLibraryDownload(this, request, options)); }
+}

package/src/sdk/sdk.ts

@@ -11,6 +11,8 @@ import { Settings } from "./settings/index.js";
 import { Users } from "./users/index.js";
 import { Admins } from "./admins.js";
 import { Tracking } from "./tracking/index.js";
+import { MediaLibrary } from "./media-library.js";
+import { Translations } from "./translations.js";
 import type { SDKOptions } from "../lib/config.js";
 import type {
   OminityModuleInput,
@@ -97,6 +99,16 @@ export class Ominity extends ClientSDK {
     return (this._admins ??= new Admins(this._options));
   }
 
+  private _mediaLibrary?: MediaLibrary;
+  get mediaLibrary(): MediaLibrary {
+    return (this._mediaLibrary ??= new MediaLibrary(this._options));
+  }
+
+  private _translations?: Translations;
+  get translations(): Translations {
+    return (this._translations ??= new Translations(this._options));
+  }
+
   protected override _propagateLanguage(language: string | undefined): void {
     this._commerce?.setLanguage(language);
     this._cms?.setLanguage(language);
@@ -108,5 +120,7 @@ export class Ominity extends ClientSDK {
     this._me?.setLanguage(language);
     this._users?.setLanguage(language);
     this._admins?.setLanguage(language);
+    this._mediaLibrary?.setLanguage(language);
+    this._translations?.setLanguage(language);
   }
 }

package/src/sdk/settings/configured-languages.ts

@@ -0,0 +1,7 @@
+import { configuredLanguagesList } from "../../funcs/settings/configuredLanguages.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+export class ConfiguredLanguages extends ClientSDK {
+  async list(request: operations.ListConfiguredLanguagesRequest = {}, options?: RequestOptions): Promise<operations.ListConfiguredLanguagesResponse> { return unwrapAsync(configuredLanguagesList(this, request, options)); }
+}

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

@@ -0,0 +1,8 @@
+import { settingCustomerGroupsGet, settingCustomerGroupsList } from "../../funcs/settings/customerGroups.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.ListSettingCustomerGroupsRequest = {}, options?: RequestOptions): Promise<operations.ListSettingCustomerGroupsResponse> { return unwrapAsync(settingCustomerGroupsList(this, request, options)); }
+  async get(request: operations.GetSettingCustomerGroupRequest, options?: RequestOptions): Promise<operations.GetSettingCustomerGroupResponse> { return unwrapAsync(settingCustomerGroupsGet(this, request, options)); }
+}

package/src/sdk/settings/index.ts

@@ -6,15 +6,24 @@ import { ClientSDK } from "../../lib/sdks.js";
 import { Countries } from "./countries.js";
 import { SocialProviders } from "./social-providers.js";
 import { PaymentMethods } from "./payment-methods.js";
+import { CustomerGroups } from "./customer-groups.js";
+import { PaymentMethodIssuers } from "./payment-method-issuers.js";
+import { ConfiguredLanguages } from "./configured-languages.js";
 
 export { Countries } from "./countries.js";
 export { SocialProviders } from "./social-providers.js";
 export { PaymentMethods } from "./payment-methods.js";
+export { CustomerGroups } from "./customer-groups.js";
+export { PaymentMethodIssuers } from "./payment-method-issuers.js";
+export { ConfiguredLanguages } from "./configured-languages.js";
 
 export class Settings extends ClientSDK {
     private _countries?: Countries;
     private _socialProviders?: SocialProviders;
     private _paymentMethods?: PaymentMethods;
+    private _customerGroups?: CustomerGroups;
+    private _paymentMethodIssuers?: PaymentMethodIssuers;
+    private _languages?: ConfiguredLanguages;
 
     get countries(): Countries {
         return (this._countries ??= new Countries(this._options));
@@ -28,9 +37,16 @@ export class Settings extends ClientSDK {
         return (this._paymentMethods ??= new PaymentMethods(this._options));
     }
 
+    get customerGroups(): CustomerGroups { return (this._customerGroups ??= new CustomerGroups(this._options)); }
+    get paymentMethodIssuers(): PaymentMethodIssuers { return (this._paymentMethodIssuers ??= new PaymentMethodIssuers(this._options)); }
+    get languages(): ConfiguredLanguages { return (this._languages ??= new ConfiguredLanguages(this._options)); }
+
     protected override _propagateLanguage(language: string | undefined): void {
         this._countries?.setLanguage(language);
         this._socialProviders?.setLanguage(language);
         this._paymentMethods?.setLanguage(language);
+        this._customerGroups?.setLanguage(language);
+        this._paymentMethodIssuers?.setLanguage(language);
+        this._languages?.setLanguage(language);
     }
 }

package/src/sdk/settings/payment-method-issuers.ts

@@ -0,0 +1,8 @@
+import { paymentMethodIssuersGet, paymentMethodIssuersList } from "../../funcs/settings/paymentMethodIssuers.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+export class PaymentMethodIssuers extends ClientSDK {
+  async list(request: operations.ListPaymentMethodIssuersRequest, options?: RequestOptions): Promise<operations.ListPaymentMethodIssuersResponse> { return unwrapAsync(paymentMethodIssuersList(this, request, options)); }
+  async get(request: operations.GetPaymentMethodIssuerRequest, options?: RequestOptions): Promise<operations.GetPaymentMethodIssuerResponse> { return unwrapAsync(paymentMethodIssuersGet(this, request, options)); }
+}

package/src/sdk/translations.ts

@@ -0,0 +1,7 @@
+import { translationsBulk } from "../funcs/translations.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+export class Translations extends ClientSDK {
+  async bulk(request: operations.BulkTranslateRequest, options?: RequestOptions): Promise<operations.BulkTranslateResponse> { return unwrapAsync(translationsBulk(this, request, options)); }
+}