@ominity/api-typescript 1.4.3 → 1.4.5

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;

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