@ominity/api-typescript 1.4.2 → 1.4.4

package/src/models/commerce/subscription.ts

@@ -0,0 +1,67 @@
+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";
+import { SubscriptionInterval, SubscriptionInterval$inboundSchema } from "./subscription-interval.js";
+
+export type SubscriptionPeriod = {
+  startedAt: string;
+  endsAt: string;
+  daysLeft: number;
+};
+
+export type Subscription = {
+  resource: "subscription";
+  id: number;
+  customerId: number;
+  productId: number;
+  intervalId: number;
+  status: string;
+  firstAmount: CurrencyAmount;
+  recurringAmount: CurrencyAmount;
+  currentPeriod: SubscriptionPeriod;
+  isPausable: boolean;
+  expiresAt: string | null;
+  dueAt: string | null;
+  updatedAt: string;
+  createdAt: string;
+  product?: Product;
+  interval?: SubscriptionInterval;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const SubscriptionPeriod$inboundSchema: z.ZodType<SubscriptionPeriod> = z.object({
+  startedAt: z.string(),
+  endsAt: z.string(),
+  daysLeft: z.number(),
+});
+
+/** @internal */
+export const Subscription$inboundSchema: z.ZodType<Subscription> = z.object({
+  resource: z.literal("subscription"),
+  id: z.number().int(),
+  customerId: z.number().int(),
+  productId: z.number().int(),
+  intervalId: z.number().int(),
+  status: z.string(),
+  firstAmount: CurrencyAmount$inboundSchema,
+  recurringAmount: CurrencyAmount$inboundSchema,
+  currentPeriod: SubscriptionPeriod$inboundSchema,
+  isPausable: z.boolean(),
+  expiresAt: z.string().nullable(),
+  dueAt: z.string().nullable(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _embedded: z.object({
+    product: Product$inboundSchema.optional(),
+    interval: SubscriptionInterval$inboundSchema.optional(),
+  }).optional(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((value) => {
+  const subscription = remap$(value, { _links: "links" }) as Subscription;
+  if (value._embedded?.product) subscription.product = value._embedded.product;
+  if (value._embedded?.interval) subscription.interval = value._embedded.interval;
+  return subscription;
+});

package/src/models/index.ts

@@ -6,3 +6,4 @@ export * from "./commerce/index.js";
 export * from "./localization/index.js";
 export * from "./hal.js";
 export * from "./pagination.js";
+export * from "./media-library.js";

package/src/models/media-library.ts

@@ -0,0 +1,86 @@
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "./hal.js";
+
+export type MediaFolder = {
+  type: "folder";
+  name: string;
+  path: string;
+  locked: boolean;
+  links?: HalLinks;
+};
+
+export type MediaItem = {
+  type: "file";
+  name: string;
+  path: string;
+  mime_type: string | null;
+  size: number | null;
+  url: string | null;
+  thumbnail_url: string | null;
+  meta: Record<string, unknown>;
+  links?: HalLinks;
+};
+
+export type MediaList = {
+  path: string;
+  folders: Array<MediaFolder>;
+  files: Array<MediaItem>;
+  links?: HalLinks;
+};
+
+export type PresignedMediaUpload = {
+  key: string;
+  url: string;
+  headers: Record<string, string>;
+  publicUrl: string;
+  path: string;
+  filename: string;
+};
+
+/** @internal */
+export const MediaFolder$inboundSchema: z.ZodType<MediaFolder> = z.object({
+  type: z.literal("folder"),
+  name: z.string(),
+  path: z.string(),
+  locked: z.boolean(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => remap$(value, { _links: "links" }) as MediaFolder);
+
+/** @internal */
+export const MediaItem$inboundSchema: z.ZodType<MediaItem> = z.object({
+  type: z.literal("file"),
+  name: z.string(),
+  path: z.string(),
+  mime_type: z.string().nullable(),
+  size: z.number().int().nullable(),
+  url: z.string().nullable(),
+  thumbnail_url: z.string().nullable().optional().default(null),
+  meta: z.record(z.string(), z.unknown()).optional().default({}),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => remap$(value, { _links: "links" }) as MediaItem);
+
+/** @internal */
+export const MediaList$inboundSchema: z.ZodType<MediaList> = z.object({
+  path: z.string(),
+  _embedded: z.object({
+    folders: z.array(MediaFolder$inboundSchema),
+    files: z.array(MediaItem$inboundSchema),
+  }),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => ({
+  path: value.path,
+  folders: value._embedded.folders,
+  files: value._embedded.files,
+  ...(value._links ? { links: value._links } : {}),
+}));
+
+/** @internal */
+export const PresignedMediaUpload$inboundSchema: z.ZodType<PresignedMediaUpload> = z.object({
+  key: z.string(),
+  url: z.string(),
+  headers: z.record(z.string(), z.string()),
+  publicUrl: z.string(),
+  path: z.string(),
+  filename: z.string(),
+});

package/src/models/operations/cms-components.ts

@@ -7,6 +7,7 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { buildPaginated, Paginated } from "../pagination.js";
 import { Component, Component$inboundSchema } from "../cms/component.js";
 import { HalLinks$inboundSchema } from "../hal.js";
+import { ComponentField, ComponentField$inboundSchema } from "../cms/component-field.js";
 
 export type ListComponentsRequest = {
     /**
@@ -102,3 +103,15 @@ export const GetComponentRequest$outboundSchema: z.ZodType<
 export const GetComponentResponse$inboundSchema: z.ZodType<
     GetComponentResponse
 > = Component$inboundSchema;
+
+export type ListComponentFieldsRequest = { componentId: number; filter?: Record<string, unknown> | undefined; sort?: string | undefined; page?: number | undefined; limit?: number | undefined };
+export type ListComponentFieldsResponse = Paginated<ComponentField>;
+export const ListComponentFieldsRequest$outboundSchema: z.ZodType<ListComponentFieldsRequest> = z.object({ componentId: z.number().int(), 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() });
+export const ListComponentFieldsResponse$inboundSchema: z.ZodType<ListComponentFieldsResponse> = z.object({
+    _embedded: z.object({ component_fields: z.array(ComponentField$inboundSchema) }), count: z.number(), _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => buildPaginated(value._embedded.component_fields, value.count, value._links));
+
+export type GetComponentFieldRequest = { componentId: number; id: number };
+export type GetComponentFieldResponse = ComponentField;
+export const GetComponentFieldRequest$outboundSchema: z.ZodType<GetComponentFieldRequest> = z.object({ componentId: z.number().int(), id: z.number().int() });
+export const GetComponentFieldResponse$inboundSchema = ComponentField$inboundSchema;

package/src/models/operations/cms-pages.ts

@@ -8,6 +8,7 @@ import { buildPaginated, Paginated } from "../pagination.js";
 import { Page, Page$inboundSchema } from "../cms/page.js";
 import { PageComponent, PageComponent$inboundSchema } from "../cms/page-component.js";
 import { HalLinks$inboundSchema } from "../hal.js";
+import { PageComponentField, PageComponentField$inboundSchema } from "../cms/page-component-field.js";
 
 export type ListPagesRequest = {
     /**
@@ -135,3 +136,13 @@ export const ListPageComponentsResponse$inboundSchema: z.ZodType<
         v._links,
     )
 );
+
+export type GetPageComponentRequest = { pageId: number; id: number };
+export type GetPageComponentResponse = PageComponent;
+export const GetPageComponentRequest$outboundSchema: z.ZodType<GetPageComponentRequest> = z.object({ pageId: z.number().int(), id: z.number().int() });
+export const GetPageComponentResponse$inboundSchema = PageComponent$inboundSchema;
+
+export type GetPageComponentFieldRequest = { pageId: number; pageComponentId: number; id: number };
+export type GetPageComponentFieldResponse = PageComponentField;
+export const GetPageComponentFieldRequest$outboundSchema: z.ZodType<GetPageComponentFieldRequest> = z.object({ pageId: z.number().int(), pageComponentId: z.number().int(), id: z.number().int() });
+export const GetPageComponentFieldResponse$inboundSchema = PageComponentField$inboundSchema;

package/src/models/operations/cms-routes.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Route, Route$inboundSchema } from "../commerce/route.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListCmsRoutesRequest = ListRequest;
+export type ListCmsRoutesResponse = Paginated<Route>;
+export const ListCmsRoutesRequest$outboundSchema: z.ZodType<ListCmsRoutesRequest> = ListRequest$outboundSchema;
+export const ListCmsRoutesResponse$inboundSchema = paginatedSchema("routes", Route$inboundSchema);
+export type GetCmsRouteRequest = { id: number };
+export type GetCmsRouteResponse = Route;
+export const GetCmsRouteRequest$outboundSchema: z.ZodType<GetCmsRouteRequest> = z.object({ id: z.number().int() });
+export const GetCmsRouteResponse$inboundSchema = Route$inboundSchema;

package/src/models/operations/commerce-carts.ts

@@ -6,6 +6,8 @@ import * as z from "zod/v4";
 import { buildPaginated, Paginated } from "../pagination.js";
 import { Cart, Cart$inboundSchema } from "../commerce/cart.js";
 import { HalLinks$inboundSchema } from "../hal.js";
+import { ShippingMethod, ShippingMethod$inboundSchema } from "../commerce/shipping-method.js";
+import { ShippingZone, ShippingZone$inboundSchema } from "../commerce/shipping-zone.js";
 
 export type ListCartsRequest = {
   /**
@@ -107,3 +109,15 @@ export const UpdateCartRequest$outboundSchema: z.ZodType<UpdateCartRequest> = z.
 });
 /** @internal */
 export const UpdateCartResponse$inboundSchema: z.ZodType<UpdateCartResponse> = Cart$inboundSchema;
+
+export type ListCartShippingMethodsRequest = { cartId: string };
+export type ListCartShippingMethodsResponse = Paginated<ShippingMethod> & { shippingZone?: ShippingZone };
+export const ListCartShippingMethodsRequest$outboundSchema: z.ZodType<ListCartShippingMethodsRequest> = z.object({ cartId: z.string() });
+export const ListCartShippingMethodsResponse$inboundSchema: z.ZodType<ListCartShippingMethodsResponse> = z.object({
+  _embedded: z.object({ shipping_methods: z.array(ShippingMethod$inboundSchema), shipping_zone: ShippingZone$inboundSchema.optional() }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => ({
+  ...buildPaginated(value._embedded.shipping_methods, value.count, value._links),
+  ...(value._embedded.shipping_zone ? { shippingZone: value._embedded.shipping_zone } : {}),
+}));

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

@@ -0,0 +1,47 @@
+import * as z from "zod/v4";
+import { Address, Address$inboundSchema } from "../commerce/address.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type AddressInput = {
+  firstName?: string | null | undefined;
+  lastName?: string | null | undefined;
+  street: string;
+  number: string;
+  additional?: string | null | undefined;
+  postalCode: string;
+  city: string;
+  region?: string | null | undefined;
+  country: string;
+};
+
+const AddressInputSchema = z.object({
+  firstName: z.string().nullable().optional(), lastName: z.string().nullable().optional(), street: z.string(), number: z.string(),
+  additional: z.string().nullable().optional(), postalCode: z.string(), city: z.string(), region: z.string().nullable().optional(), country: z.string(),
+});
+
+export type ListCustomerAddressesRequest = ListRequest & { customerId: number };
+export type ListCustomerAddressesResponse = Paginated<Address>;
+export const ListCustomerAddressesRequest$outboundSchema: z.ZodType<ListCustomerAddressesRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int() });
+export const ListCustomerAddressesResponse$inboundSchema: z.ZodType<ListCustomerAddressesResponse> = paginatedSchema("addresses", Address$inboundSchema);
+
+export type GetCustomerAddressRequest = { customerId: number; id: number };
+export type GetCustomerAddressResponse = Address;
+export const GetCustomerAddressRequest$outboundSchema: z.ZodType<GetCustomerAddressRequest> = z.object({ customerId: z.number().int(), id: z.number().int() });
+export const GetCustomerAddressResponse$inboundSchema = Address$inboundSchema;
+
+export type CreateCustomerAddressRequest = { customerId: number; data: AddressInput };
+export type CreateCustomerAddressResponse = Address;
+export const CreateCustomerAddressRequest$outboundSchema: z.ZodType<CreateCustomerAddressRequest> = z.object({ customerId: z.number().int(), data: AddressInputSchema });
+export const CreateCustomerAddressResponse$inboundSchema = Address$inboundSchema;
+
+export type AddressUpdateInput = { [Key in keyof AddressInput]?: AddressInput[Key] | undefined };
+export type UpdateCustomerAddressRequest = { customerId: number; id: number; data: AddressUpdateInput };
+export type UpdateCustomerAddressResponse = Address;
+export const UpdateCustomerAddressRequest$outboundSchema: z.ZodType<UpdateCustomerAddressRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), data: AddressInputSchema.partial() });
+export const UpdateCustomerAddressResponse$inboundSchema = Address$inboundSchema;
+
+export type DeleteCustomerAddressRequest = { customerId: number; id: number };
+export type DeleteCustomerAddressResponse = void;
+export const DeleteCustomerAddressRequest$outboundSchema: z.ZodType<DeleteCustomerAddressRequest> = GetCustomerAddressRequest$outboundSchema;
+export const DeleteCustomerAddressResponse$inboundSchema: z.ZodType<void> = z.void();

package/src/models/operations/commerce-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 ListCustomerGroupsRequest = ListRequest & { customerId: number };
+export type ListCustomerGroupsResponse = Paginated<CustomerGroup>;
+export const ListCustomerGroupsRequest$outboundSchema: z.ZodType<ListCustomerGroupsRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int() });
+export const ListCustomerGroupsResponse$inboundSchema = paginatedSchema("customer_groups", CustomerGroup$inboundSchema);
+export type GetCustomerGroupRequest = { customerId: number; id: number; include?: string | undefined };
+export type GetCustomerGroupResponse = CustomerGroup;
+export const GetCustomerGroupRequest$outboundSchema: z.ZodType<GetCustomerGroupRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), include: z.string().optional() });
+export const GetCustomerGroupResponse$inboundSchema = CustomerGroup$inboundSchema;

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

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Invoice, Invoice$inboundSchema } from "../commerce/invoice.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListCustomerInvoicesRequest = ListRequest & { customerId: number };
+export type ListCustomerInvoicesResponse = Paginated<Invoice>;
+export const ListCustomerInvoicesRequest$outboundSchema: z.ZodType<ListCustomerInvoicesRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int() });
+export const ListCustomerInvoicesResponse$inboundSchema = paginatedSchema("invoices", Invoice$inboundSchema);
+export type GetCustomerInvoiceRequest = { customerId: number; id: number; include?: string | undefined };
+export type GetCustomerInvoiceResponse = Invoice;
+export const GetCustomerInvoiceRequest$outboundSchema: z.ZodType<GetCustomerInvoiceRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), include: z.string().optional() });
+export const GetCustomerInvoiceResponse$inboundSchema = Invoice$inboundSchema;
+export type DownloadCustomerInvoicePdfRequest = { customerId: number; id: number };
+export type DownloadCustomerInvoicePdfResponse = Uint8Array;
+export const DownloadCustomerInvoicePdfRequest$outboundSchema: z.ZodType<DownloadCustomerInvoicePdfRequest> = z.object({ customerId: z.number().int(), id: z.number().int() });
+export const DownloadCustomerInvoicePdfResponse$inboundSchema: z.ZodType<Uint8Array> = z.instanceof(Uint8Array);

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

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { Mandate, Mandate$inboundSchema } from "../commerce/mandate.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListCustomerMandatesRequest = ListRequest & { customerId: number };
+export type ListCustomerMandatesResponse = Paginated<Mandate>;
+export const ListCustomerMandatesRequest$outboundSchema: z.ZodType<ListCustomerMandatesRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int() });
+export const ListCustomerMandatesResponse$inboundSchema = paginatedSchema("mandates", Mandate$inboundSchema);
+
+export type GetCustomerMandateRequest = { customerId: number; id: number };
+export type GetCustomerMandateResponse = Mandate;
+export const GetCustomerMandateRequest$outboundSchema: z.ZodType<GetCustomerMandateRequest> = z.object({ customerId: z.number().int(), id: z.number().int() });
+export const GetCustomerMandateResponse$inboundSchema = Mandate$inboundSchema;
+
+export type CreateCustomerMandateRequest = { customerId: number; data: Record<string, unknown> };
+export type CreateCustomerMandateResponse = Mandate;
+export const CreateCustomerMandateRequest$outboundSchema: z.ZodType<CreateCustomerMandateRequest> = z.object({ customerId: z.number().int(), data: z.record(z.string(), z.unknown()) });
+export const CreateCustomerMandateResponse$inboundSchema = Mandate$inboundSchema;
+
+export type UpdateCustomerMandateRequest = { customerId: number; id: number; data: Record<string, unknown> };
+export type UpdateCustomerMandateResponse = Mandate;
+export const UpdateCustomerMandateRequest$outboundSchema: z.ZodType<UpdateCustomerMandateRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), data: z.record(z.string(), z.unknown()) });
+export const UpdateCustomerMandateResponse$inboundSchema = Mandate$inboundSchema;
+
+export type DeleteCustomerMandateRequest = { customerId: number; id: number };
+export type DeleteCustomerMandateResponse = void;
+export const DeleteCustomerMandateRequest$outboundSchema: z.ZodType<DeleteCustomerMandateRequest> = GetCustomerMandateRequest$outboundSchema;
+export const DeleteCustomerMandateResponse$inboundSchema: z.ZodType<void> = z.void();

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

@@ -0,0 +1,25 @@
+import * as z from "zod/v4";
+import { Order, Order$inboundSchema } from "../commerce/order.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListCustomerOrdersRequest = ListRequest & { customerId: number };
+export type ListCustomerOrdersResponse = Paginated<Order>;
+export const ListCustomerOrdersRequest$outboundSchema: z.ZodType<ListCustomerOrdersRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int() });
+export const ListCustomerOrdersResponse$inboundSchema = paginatedSchema("orders", Order$inboundSchema);
+export type GetCustomerOrderRequest = { customerId: number; id: number; include?: string | undefined };
+export type GetCustomerOrderResponse = Order;
+export const GetCustomerOrderRequest$outboundSchema: z.ZodType<GetCustomerOrderRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), include: z.string().optional() });
+export const GetCustomerOrderResponse$inboundSchema = Order$inboundSchema;
+export type CreateCustomerOrderRequest = { customerId: number; data: Record<string, unknown> };
+export type CreateCustomerOrderResponse = Order;
+export const CreateCustomerOrderRequest$outboundSchema: z.ZodType<CreateCustomerOrderRequest> = z.object({ customerId: z.number().int(), data: z.record(z.string(), z.unknown()) });
+export const CreateCustomerOrderResponse$inboundSchema = Order$inboundSchema;
+export type UpdateCustomerOrderRequest = { customerId: number; id: number; data: Record<string, unknown> };
+export type UpdateCustomerOrderResponse = Order;
+export const UpdateCustomerOrderRequest$outboundSchema: z.ZodType<UpdateCustomerOrderRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), data: z.record(z.string(), z.unknown()) });
+export const UpdateCustomerOrderResponse$inboundSchema = Order$inboundSchema;
+export type DeleteCustomerOrderRequest = { customerId: number; id: number };
+export type DeleteCustomerOrderResponse = void;
+export const DeleteCustomerOrderRequest$outboundSchema: z.ZodType<DeleteCustomerOrderRequest> = z.object({ customerId: z.number().int(), id: z.number().int() });
+export const DeleteCustomerOrderResponse$inboundSchema: z.ZodType<void> = z.void();

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

@@ -0,0 +1,41 @@
+import * as z from "zod/v4";
+import { CurrencyAmount$outboundSchema } from "../common/amount.js";
+import { Payment, Payment$inboundSchema } from "../commerce/payment.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type PaymentInput = {
+  type?: string | undefined;
+  paymentmethodId: number;
+  issuerId?: number | null | undefined;
+  redirectUrl: string;
+  customerId?: number | null | undefined;
+  orderId?: number | undefined;
+  mandateId?: number | null | undefined;
+  amount?: z.infer<typeof CurrencyAmount$outboundSchema> | undefined;
+  invoiceId?: number | null | undefined;
+  details?: { cardToken?: string | undefined } | undefined;
+};
+
+export const PaymentInput$outboundSchema = z.object({
+  type: z.string().optional(), paymentmethodId: z.number().int(), issuerId: z.number().int().nullable().optional(), redirectUrl: z.string().url(),
+  customerId: z.number().int().nullable().optional(), orderId: z.number().int().optional(), mandateId: z.number().int().nullable().optional(),
+  amount: CurrencyAmount$outboundSchema.optional(), invoiceId: z.number().int().nullable().optional(), details: z.object({ cardToken: z.string().optional() }).optional(),
+});
+
+export type ListCustomerPaymentsRequest = ListRequest & { customerId: number };
+export type ListCustomerPaymentsResponse = Paginated<Payment>;
+export const ListCustomerPaymentsRequest$outboundSchema: z.ZodType<ListCustomerPaymentsRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int() });
+export const ListCustomerPaymentsResponse$inboundSchema = paginatedSchema("payments", Payment$inboundSchema);
+export type GetCustomerPaymentRequest = { customerId: number; id: number };
+export type GetCustomerPaymentResponse = Payment;
+export const GetCustomerPaymentRequest$outboundSchema: z.ZodType<GetCustomerPaymentRequest> = z.object({ customerId: z.number().int(), id: z.number().int() });
+export const GetCustomerPaymentResponse$inboundSchema = Payment$inboundSchema;
+export type CreateCustomerPaymentRequest = { customerId: number; include?: string | undefined; data: Omit<PaymentInput, "customerId"> };
+export type CreateCustomerPaymentResponse = Payment;
+export const CreateCustomerPaymentRequest$outboundSchema: z.ZodType<CreateCustomerPaymentRequest> = z.object({ customerId: z.number().int(), include: z.string().optional(), data: PaymentInput$outboundSchema.omit({ customerId: true }) });
+export const CreateCustomerPaymentResponse$inboundSchema = Payment$inboundSchema;
+export type DeleteCustomerPaymentRequest = { customerId: number; id: number };
+export type DeleteCustomerPaymentResponse = void;
+export const DeleteCustomerPaymentRequest$outboundSchema: z.ZodType<DeleteCustomerPaymentRequest> = GetCustomerPaymentRequest$outboundSchema;
+export const DeleteCustomerPaymentResponse$inboundSchema: z.ZodType<void> = z.void();

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

@@ -0,0 +1,45 @@
+import * as z from "zod/v4";
+import { Product, Product$inboundSchema } from "../commerce/product.js";
+import { Subscription, Subscription$inboundSchema } from "../commerce/subscription.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListCustomerSubscriptionsRequest = ListRequest & { customerId: number };
+export type ListCustomerSubscriptionsResponse = Paginated<Subscription>;
+export const ListCustomerSubscriptionsRequest$outboundSchema: z.ZodType<ListCustomerSubscriptionsRequest> = ListRequest$outboundSchema.extend({ customerId: z.number().int() });
+export const ListCustomerSubscriptionsResponse$inboundSchema = paginatedSchema("subscriptions", Subscription$inboundSchema);
+
+export type GetCustomerSubscriptionRequest = { customerId: number; id: number; include?: string | undefined };
+export type GetCustomerSubscriptionResponse = Subscription;
+export const GetCustomerSubscriptionRequest$outboundSchema: z.ZodType<GetCustomerSubscriptionRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), include: z.string().optional() });
+export const GetCustomerSubscriptionResponse$inboundSchema = Subscription$inboundSchema;
+
+export type CreateCustomerSubscriptionRequest = { customerId: number; data: Record<string, unknown> };
+export type CreateCustomerSubscriptionResponse = Subscription;
+export const CreateCustomerSubscriptionRequest$outboundSchema: z.ZodType<CreateCustomerSubscriptionRequest> = z.object({ customerId: z.number().int(), data: z.record(z.string(), z.unknown()) });
+export const CreateCustomerSubscriptionResponse$inboundSchema = Subscription$inboundSchema;
+
+export type UpdateCustomerSubscriptionRequest = { customerId: number; id: number; data: { paused?: boolean | undefined } };
+export type UpdateCustomerSubscriptionResponse = Subscription;
+export const UpdateCustomerSubscriptionRequest$outboundSchema: z.ZodType<UpdateCustomerSubscriptionRequest> = z.object({ customerId: z.number().int(), id: z.number().int(), data: z.object({ paused: z.boolean().optional() }) });
+export const UpdateCustomerSubscriptionResponse$inboundSchema = Subscription$inboundSchema;
+
+export type DeleteCustomerSubscriptionRequest = { customerId: number; id: number };
+export type DeleteCustomerSubscriptionResponse = void;
+export const DeleteCustomerSubscriptionRequest$outboundSchema: z.ZodType<DeleteCustomerSubscriptionRequest> = z.object({ customerId: z.number().int(), id: z.number().int() });
+export const DeleteCustomerSubscriptionResponse$inboundSchema: z.ZodType<void> = z.void();
+
+export type RenewCustomerSubscriptionRequest = { customerId: number; id: number; include?: string | undefined };
+export type RenewCustomerSubscriptionResponse = Subscription;
+export const RenewCustomerSubscriptionRequest$outboundSchema: z.ZodType<RenewCustomerSubscriptionRequest> = GetCustomerSubscriptionRequest$outboundSchema;
+export const RenewCustomerSubscriptionResponse$inboundSchema = Subscription$inboundSchema;
+
+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);
+
+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;

package/src/models/operations/commerce-customers.ts

@@ -0,0 +1,72 @@
+import * as z from "zod/v4";
+import { Customer, Customer$inboundSchema } from "../commerce/customer.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type CustomerOwnerInput = {
+  firstName: string;
+  lastName: string;
+  email: string;
+  password: string;
+  avatar?: string | null | undefined;
+  language?: string | null | undefined;
+};
+
+export type CustomerInput = {
+  type: string;
+  name?: string | null | undefined;
+  email?: string | null | undefined;
+  phone?: string | null | undefined;
+  companyVat?: string | null | undefined;
+  ownerId?: number | null | undefined;
+  owner?: CustomerOwnerInput | undefined;
+  billingAddressId?: number | null | undefined;
+  billingAddress?: CustomerAddressInput | undefined;
+  shippingAddressId?: number | "billingAddress" | null | undefined;
+  shippingAddress?: CustomerAddressInput | undefined;
+};
+
+export type CustomerAddressInput = {
+  firstName?: string | null | undefined;
+  lastName?: string | null | undefined;
+  street: string;
+  number: string;
+  additional: string;
+  postalCode: string;
+  city: string;
+  region?: string | null | undefined;
+  country: string;
+};
+
+export type ListCustomersRequest = ListRequest;
+export type ListCustomersResponse = Paginated<Customer>;
+export const ListCustomersRequest$outboundSchema: z.ZodType<ListCustomersRequest> = ListRequest$outboundSchema;
+export const ListCustomersResponse$inboundSchema: z.ZodType<ListCustomersResponse> = paginatedSchema("customers", Customer$inboundSchema);
+
+export type GetCustomerRequest = { id: number; include?: string | undefined };
+export type GetCustomerResponse = Customer;
+export const GetCustomerRequest$outboundSchema: z.ZodType<GetCustomerRequest> = z.object({ id: z.number().int(), include: z.string().optional() });
+export const GetCustomerResponse$inboundSchema: z.ZodType<GetCustomerResponse> = Customer$inboundSchema;
+
+export type CreateCustomerRequest = { data: CustomerInput };
+export type CreateCustomerResponse = Customer;
+const CustomerInput$outboundSchema = z.object({
+    type: z.string(), name: z.string().nullable().optional(), email: z.string().email().nullable().optional(),
+    phone: z.string().nullable().optional(), companyVat: z.string().nullable().optional(), ownerId: z.number().int().nullable().optional(),
+    owner: z.object({ firstName: z.string(), lastName: z.string(), email: z.string().email(), password: z.string(), avatar: z.string().url().nullable().optional(), language: z.string().length(2).nullable().optional() }).optional(),
+    billingAddressId: z.number().int().nullable().optional(), billingAddress: z.object({ firstName: z.string().nullable().optional(), lastName: z.string().nullable().optional(), street: z.string(), number: z.string(), additional: z.string(), postalCode: z.string(), city: z.string(), region: z.string().nullable().optional(), country: z.string() }).optional(),
+    shippingAddressId: z.union([z.number().int(), z.literal("billingAddress"), z.null()]).optional(), shippingAddress: z.object({ firstName: z.string().nullable().optional(), lastName: z.string().nullable().optional(), street: z.string(), number: z.string(), additional: z.string(), postalCode: z.string(), city: z.string(), region: z.string().nullable().optional(), country: z.string() }).optional(),
+});
+export const CreateCustomerRequest$outboundSchema: z.ZodType<CreateCustomerRequest> = z.object({
+  data: CustomerInput$outboundSchema,
+});
+export const CreateCustomerResponse$inboundSchema: z.ZodType<CreateCustomerResponse> = Customer$inboundSchema;
+
+export type CustomerUpdateInput = { [Key in keyof Omit<CustomerInput, "owner" | "billingAddress" | "shippingAddress">]?: CustomerInput[Key] | undefined };
+export type UpdateCustomerRequest = { id: number; data: CustomerUpdateInput };
+export type UpdateCustomerResponse = Customer;
+export const UpdateCustomerRequest$outboundSchema: z.ZodType<UpdateCustomerRequest> = z.object({
+  id: z.number().int(),
+  data: CustomerInput$outboundSchema.partial().omit({ owner: true, billingAddress: true, shippingAddress: true }),
+});
+export const UpdateCustomerResponse$inboundSchema: z.ZodType<UpdateCustomerResponse> = Customer$inboundSchema;

package/src/models/operations/commerce-invoices.ts

@@ -85,3 +85,18 @@ export const GetInvoiceRequest$outboundSchema: z.ZodType<
 export const GetInvoiceResponse$inboundSchema: z.ZodType<
     GetInvoiceResponse
 > = Invoice$inboundSchema;
+
+export type CreateInvoiceRequest = { data: Record<string, unknown> };
+export type CreateInvoiceResponse = Invoice;
+export const CreateInvoiceRequest$outboundSchema: z.ZodType<CreateInvoiceRequest> = z.object({ data: z.record(z.string(), z.unknown()) });
+export const CreateInvoiceResponse$inboundSchema = Invoice$inboundSchema;
+
+export type UpdateInvoiceRequest = { id: number; data: Record<string, unknown> };
+export type UpdateInvoiceResponse = Invoice;
+export const UpdateInvoiceRequest$outboundSchema: z.ZodType<UpdateInvoiceRequest> = z.object({ id: z.number().int(), data: z.record(z.string(), z.unknown()) });
+export const UpdateInvoiceResponse$inboundSchema = Invoice$inboundSchema;
+
+export type DownloadInvoicePdfRequest = { id: number };
+export type DownloadInvoicePdfResponse = Uint8Array;
+export const DownloadInvoicePdfRequest$outboundSchema: z.ZodType<DownloadInvoicePdfRequest> = z.object({ id: z.number().int() });
+export const DownloadInvoicePdfResponse$inboundSchema: z.ZodType<Uint8Array> = z.instanceof(Uint8Array);

package/src/models/operations/commerce-payments.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v4";
 import { buildPaginated, Paginated } from "../pagination.js";
 import { Payment, Payment$inboundSchema } from "../commerce/payment.js";
 import { HalLinks$inboundSchema } from "../hal.js";
+import { PaymentInput, PaymentInput$outboundSchema } from "./commerce-customer-payments.js";
 
 export type ListOrderPaymentsRequest = {
     /**
@@ -134,3 +135,24 @@ export const GetPaymentRequest$outboundSchema: z.ZodType<
 export const GetPaymentResponse$inboundSchema: z.ZodType<
     GetPaymentResponse
 > = Payment$inboundSchema;
+
+export type CreatePaymentRequest = { include?: string | undefined; data: PaymentInput };
+export type CreatePaymentResponse = Payment;
+export const CreatePaymentRequest$outboundSchema: z.ZodType<CreatePaymentRequest> = z.object({ include: z.string().optional(), data: PaymentInput$outboundSchema });
+export const CreatePaymentResponse$inboundSchema = Payment$inboundSchema;
+
+export type CreateOrderPaymentRequest = {
+    orderId: string;
+    data: Pick<PaymentInput, "type" | "paymentmethodId" | "issuerId" | "mandateId" | "redirectUrl" | "details">;
+};
+export type CreateOrderPaymentResponse = Payment;
+export const CreateOrderPaymentRequest$outboundSchema: z.ZodType<CreateOrderPaymentRequest> = z.object({
+    orderId: z.string(),
+    data: PaymentInput$outboundSchema.pick({ type: true, paymentmethodId: true, issuerId: true, mandateId: true, redirectUrl: true, details: true }),
+});
+export const CreateOrderPaymentResponse$inboundSchema = Payment$inboundSchema;
+
+export type GetOrderPaymentRequest = { orderId: string; id: number };
+export type GetOrderPaymentResponse = Payment;
+export const GetOrderPaymentRequest$outboundSchema: z.ZodType<GetOrderPaymentRequest> = z.object({ orderId: z.string(), id: z.number().int() });
+export const GetOrderPaymentResponse$inboundSchema = Payment$inboundSchema;

package/src/models/operations/commerce-products.ts

@@ -144,3 +144,8 @@ export const ListProductOffersResponse$inboundSchema: z.ZodType<
     v._links,
   )
 );
+
+export type GetProductOfferRequest = { productId: number; id: number };
+export type GetProductOfferResponse = ProductOffer;
+export const GetProductOfferRequest$outboundSchema: z.ZodType<GetProductOfferRequest> = z.object({ productId: z.number().int(), id: z.number().int() });
+export const GetProductOfferResponse$inboundSchema = ProductOffer$inboundSchema;

package/src/models/operations/commerce-shipping-classes.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { ShippingClass, ShippingClass$inboundSchema } from "../commerce/shipping-class.js";
+import { Paginated } from "../pagination.js";
+import { ListRequest, ListRequest$outboundSchema, paginatedSchema } from "./helpers.js";
+
+export type ListShippingClassesRequest = ListRequest;
+export type ListShippingClassesResponse = Paginated<ShippingClass>;
+export const ListShippingClassesRequest$outboundSchema: z.ZodType<ListShippingClassesRequest> = ListRequest$outboundSchema;
+export const ListShippingClassesResponse$inboundSchema = paginatedSchema("shipping_classes", ShippingClass$inboundSchema);
+export type GetShippingClassRequest = { id: number };
+export type GetShippingClassResponse = ShippingClass;
+export const GetShippingClassRequest$outboundSchema: z.ZodType<GetShippingClassRequest> = z.object({ id: z.number().int() });
+export const GetShippingClassResponse$inboundSchema = ShippingClass$inboundSchema;