@ominity/api-typescript 1.4.3 → 1.4.5

package/src/models/commerce/mandate.ts

@@ -0,0 +1,55 @@
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type MandateDetails = {
+  holderName?: string | undefined;
+  cardNumber?: string | undefined;
+  cardType?: string | undefined;
+  cardFingerprint?: string | undefined;
+  cardExpiry?: string | undefined;
+  accountNumber?: string | undefined;
+  accountBic?: string | undefined;
+};
+
+export type Mandate = {
+  resource: "mandate";
+  id: number;
+  customerId: number;
+  paymentmethodId: number;
+  firstPaymentId: number;
+  imageUrl: string | null;
+  status: string;
+  details: MandateDetails;
+  signedAt: string | null;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const MandateDetails$inboundSchema: z.ZodType<MandateDetails> = z.object({
+  holderName: z.string().optional(),
+  cardNumber: z.string().optional(),
+  cardType: z.string().optional(),
+  cardFingerprint: z.string().optional(),
+  cardExpiry: z.string().optional(),
+  accountNumber: z.string().optional(),
+  accountBic: z.string().optional(),
+});
+
+/** @internal */
+export const Mandate$inboundSchema: z.ZodType<Mandate> = z.object({
+  resource: z.literal("mandate"),
+  id: z.number().int(),
+  customerId: z.number().int(),
+  paymentmethodId: z.number().int(),
+  firstPaymentId: z.number().int(),
+  imageUrl: z.string().nullable(),
+  status: z.string(),
+  details: MandateDetails$inboundSchema,
+  signedAt: z.string().nullable(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((value) => remap$(value, { _links: "links" }) as Mandate);

package/src/models/commerce/order.ts

@@ -18,15 +18,15 @@ export type ShippingTotals = {
 export type Order = {
     resource: string;
     id: number;
-    customerId: number;
+    customerId: number | null;
     cartId: string | null;
-    channelId: number;
+    channelId: number | null;
     languageId: number | null;
     number: string;
     invoiceId: number | null;
     status: string;
-    companyName: string;
-    companyVat: string;
+    companyName: string | null;
+    companyVat: string | null;
     billingAddress: Address;
     shippingAddress: Address;
     subtotalAmount: CurrencyAmount;
@@ -55,15 +55,15 @@ export const ShippingTotals$inboundSchema: z.ZodType<ShippingTotals> = z.object(
 export const Order$inboundSchema: z.ZodType<Order> = z.object({
     resource: z.string(),
     id: z.number(),
-    customerId: z.number(),
+    customerId: z.number().nullable(),
     cartId: z.string().nullable(),
-    channelId: z.number(),
+    channelId: z.number().nullable(),
     languageId: z.number().nullable(),
     number: z.string(),
     invoiceId: z.number().nullable(),
     status: z.string(),
-    companyName: z.string(),
-    companyVat: z.string(),
+    companyName: z.string().nullable(),
+    companyVat: z.string().nullable(),
     billingAddress: Address$inboundSchema,
     shippingAddress: Address$inboundSchema,
     subtotalAmount: CurrencyAmount$inboundSchema,

package/src/models/commerce/payment.ts

@@ -10,13 +10,15 @@ import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.j
 export type Payment = {
     resource: string;
     id: number;
-    customerId: number;
+    customerId: number | null;
     paymentmethodId: number;
     status: string;
     type: string;
     amount: CurrencyAmount;
     description: string;
-    invoiceId: number | null;
+    invoiceId?: number;
+    mandateId?: number;
+    details?: Record<string, unknown>;
     expiresAt: string | null;
     completedAt: string | null;
     updatedAt: string;
@@ -28,13 +30,15 @@ export type Payment = {
 export const Payment$inboundSchema: z.ZodType<Payment> = z.object({
     resource: z.string(),
     id: z.number(),
-    customerId: z.number(),
+    customerId: z.number().nullable(),
     paymentmethodId: z.number(),
     status: z.string(),
     type: z.string(),
     amount: CurrencyAmount$inboundSchema,
     description: z.string(),
-    invoiceId: z.nullable(z.number()),
+    invoiceId: z.number().optional(),
+    mandateId: z.number().optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
     expiresAt: z.string().nullable(),
     completedAt: z.string().nullable(),
     updatedAt: z.string(),

package/src/models/commerce/product.ts

@@ -14,8 +14,8 @@ export type ProductRoute = {
 };
 
 export type ProductMeasurement = {
-  value: number;
-  unit: string;
+  value: number | null;
+  unit: string | null;
 };
 
 export type ProductMeasurements = {
@@ -33,7 +33,7 @@ export type ProductReviewBreakdown = {
 export type ProductReviews = {
   total: number;
   rating: number | null;
-  breakdown: Array<ProductReviewBreakdown>;
+  breakdown: Record<string, number> | Array<ProductReviewBreakdown>;
 };
 
 export type Product = {
@@ -54,7 +54,7 @@ export type Product = {
   type: string;
   condition: string;
   categoryId: number;
-  stock: number;
+  stock: number | null;
   isBackorderAllowed: boolean;
   routes: Record<string, ProductRoute>;
   measurements?: ProductMeasurements;
@@ -77,8 +77,8 @@ export const ProductRoute$inboundSchema: z.ZodType<ProductRoute> = z.object({
 
 /** @internal */
 export const ProductMeasurement$inboundSchema: z.ZodType<ProductMeasurement> = z.object({
-  value: z.number(),
-  unit: z.string(),
+  value: z.number().nullable(),
+  unit: z.string().nullable(),
 });
 
 /** @internal */
@@ -99,7 +99,10 @@ export const ProductReviewBreakdown$inboundSchema: z.ZodType<ProductReviewBreakd
 export const ProductReviews$inboundSchema: z.ZodType<ProductReviews> = z.object({
   total: z.number(),
   rating: z.nullable(z.number()),
-  breakdown: z.array(ProductReviewBreakdown$inboundSchema),
+  breakdown: z.union([
+    z.record(z.string(), z.number()),
+    z.array(ProductReviewBreakdown$inboundSchema),
+  ]),
 });
 
 /** @internal */
@@ -121,7 +124,7 @@ export const Product$inboundSchema: z.ZodType<Product> = z.object({
   type: z.string(),
   condition: z.string(),
   categoryId: z.number(),
-  stock: z.number(),
+  stock: z.number().nullable(),
   isBackorderAllowed: z.boolean(),
   routes: z.record(z.string(), ProductRoute$inboundSchema),
   measurements: ProductMeasurements$inboundSchema.optional(),

package/src/models/commerce/shipping-class.ts

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

package/src/models/commerce/shipping-method.ts

@@ -1,36 +1,53 @@
 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";
 
+export type ShippingMethodContext = {
+  subtotalAmount: CurrencyAmount;
+  taxAmount: CurrencyAmount;
+  totalAmount: CurrencyAmount;
+  taxRate: number;
+};
 
-// Placeholder - waiting for actual data structure from user
 export type ShippingMethod = {
-    id?: string;
-    name?: string;
-    [key: string]: any;
+  resource: "shipping_method";
+  id: number;
+  zoneId: number;
+  classId: number | null;
+  deliveryTimeId: number | null;
+  name: string;
+  description: string | null;
+  isEnabled: boolean;
+  context?: ShippingMethodContext | undefined;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks | undefined;
 };
 
 /** @internal */
-export const ShippingMethod$inboundSchema: z.ZodType<ShippingMethod> = z
-    .object({
-        id: z.string().optional(),
-        name: z.string().optional(),
-    })
-    .passthrough() as unknown as z.ZodType<ShippingMethod>;
+export const ShippingMethodContext$inboundSchema: z.ZodType<ShippingMethodContext> = z.object({
+  subtotalAmount: CurrencyAmount$inboundSchema,
+  taxAmount: CurrencyAmount$inboundSchema,
+  totalAmount: CurrencyAmount$inboundSchema,
+  taxRate: z.number(),
+});
 
 /** @internal */
-export const ShippingMethod$outboundSchema: z.ZodType<ShippingMethod> = z
-    .object({
-        id: z.string().optional(),
-        name: z.string().optional(),
-    })
-    .passthrough() as unknown as z.ZodType<ShippingMethod>;
+export const ShippingMethod$inboundSchema: z.ZodType<ShippingMethod> = z.object({
+  resource: z.literal("shipping_method"),
+  id: z.number().int(),
+  zoneId: z.number().int(),
+  classId: z.number().int().nullable(),
+  deliveryTimeId: z.number().int().nullable(),
+  name: z.string(),
+  description: z.string().nullable(),
+  isEnabled: z.boolean(),
+  context: ShippingMethodContext$inboundSchema.optional(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((value) => remap$(value, { _links: "links" }) as ShippingMethod);
 
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ShippingMethod$ {
-    /** @deprecated use `ShippingMethod$inboundSchema` instead. */
-    export const inboundSchema = ShippingMethod$inboundSchema;
-    /** @deprecated use `ShippingMethod$outboundSchema` instead. */
-    export const outboundSchema = ShippingMethod$outboundSchema;
-}
+/** @internal */
+export const ShippingMethod$outboundSchema = ShippingMethod$inboundSchema;

package/src/models/commerce/shipping-zone.ts

@@ -1,101 +1,33 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-
-export type ShippingZoneLinks = {
-    self: {
-        href: string;
-        type: string;
-    };
-};
-
-/** @internal */
-export const ShippingZoneLinks$inboundSchema: z.ZodType<ShippingZoneLinks> = z.object({
-    self: z.object({
-        href: z.string(),
-        type: z.string(),
-    }),
-});
-
-/** @internal */
-export const ShippingZoneLinks$outboundSchema: z.ZodType<ShippingZoneLinks> = z.object({
-    self: z.object({
-        href: z.string(),
-        type: z.string(),
-    }),
-});
-
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ShippingZoneLinks$ {
-    /** @deprecated use `ShippingZoneLinks$inboundSchema` instead. */
-    export const inboundSchema = ShippingZoneLinks$inboundSchema;
-    /** @deprecated use `ShippingZoneLinks$outboundSchema` instead. */
-    export const outboundSchema = ShippingZoneLinks$outboundSchema;
-}
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
 
 export type ShippingZone = {
-    resource: string;
-    id: string;
-    name: string;
-    regions?: Array<string> | null;
-    order?: number | null;
-    isActive: boolean;
-    isDefault: boolean;
-    updatedAt: string;
-    createdAt: string;
-    links: ShippingZoneLinks;
+  resource: "shipping_zone";
+  id: number;
+  name: string;
+  regions: Record<string, unknown>;
+  order: number | null;
+  isActive: boolean;
+  isDefault: boolean;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks | undefined;
 };
 
 /** @internal */
-export const ShippingZone$inboundSchema: z.ZodType<ShippingZone> = z
-    .object({
-        resource: z.string(),
-        id: z.string(),
-        name: z.string(),
-        regions: z.array(z.string()).optional().nullable(),
-        order: z.number().int().optional().nullable(),
-        isActive: z.boolean(),
-        isDefault: z.boolean(),
-        updatedAt: z.string(),
-        createdAt: z.string(),
-        _links: ShippingZoneLinks$inboundSchema,
-    })
-    .transform((v) => {
-        return remap$(v, {
-            _links: "links",
-        });
-    }) as unknown as z.ZodType<ShippingZone>;
+export const ShippingZone$inboundSchema: z.ZodType<ShippingZone> = z.object({
+  resource: z.literal("shipping_zone"),
+  id: z.number().int(),
+  name: z.string(),
+  regions: z.record(z.string(), z.unknown()),
+  order: z.number().nullable(),
+  isActive: z.boolean(),
+  isDefault: z.boolean(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((value) => remap$(value, { _links: "links" }) as ShippingZone);
 
 /** @internal */
-export const ShippingZone$outboundSchema: z.ZodType<ShippingZone> = z
-    .object({
-        resource: z.string(),
-        id: z.string(),
-        name: z.string(),
-        regions: z.array(z.string()).optional().nullable(),
-        order: z.number().int().optional().nullable(),
-        isActive: z.boolean(),
-        isDefault: z.boolean(),
-        updatedAt: z.string(),
-        createdAt: z.string(),
-        links: ShippingZoneLinks$outboundSchema,
-    })
-    .transform((v) => {
-        return remap$(v, {
-            links: "_links",
-        });
-    }) as unknown as z.ZodType<ShippingZone>;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ShippingZone$ {
-    /** @deprecated use `ShippingZone$inboundSchema` instead. */
-    export const inboundSchema = ShippingZone$inboundSchema;
-    /** @deprecated use `ShippingZone$outboundSchema` instead. */
-    export const outboundSchema = ShippingZone$outboundSchema;
-}
+export const ShippingZone$outboundSchema = ShippingZone$inboundSchema;

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