@ominity/api-typescript 1.4.3 → 1.4.4

package/src/funcs/commerce/vatValidationsGet.ts

@@ -44,7 +44,7 @@ async function $do(
         | RequestTimeoutError
     >
 > {
-    const path = pathToFunc("/commerce/vat-validations/{number}")({
+    const path = pathToFunc("/commerce/vatvalidations/{number}")({
         number: request.vatNumber,
     });
 
@@ -118,4 +118,3 @@ async function $do(
 
     return result;
 }
-

package/src/funcs/index.ts

@@ -22,3 +22,21 @@ export * from "./oauth2/index.js";
 export * from "./meGet.js";
 export * from "./users/index.js";
 export * from "./admins/index.js";
+export * from "./commerce/customers.js";
+export * from "./commerce/customerAddresses.js";
+export * from "./commerce/customerGroups.js";
+export * from "./commerce/customerMandates.js";
+export * from "./commerce/customerPayments.js";
+export * from "./commerce/customerOrders.js";
+export * from "./commerce/customerInvoices.js";
+export * from "./commerce/customerSubscriptions.js";
+export * from "./commerce/shippingClasses.js";
+export * from "./commerce/invoicesMutations.js";
+export * from "./commerce/paymentsMutations.js";
+export * from "./commerce/productsOfferGet.js";
+export * from "./commerce/cartShippingMethods.js";
+export * from "./settings/customerGroups.js";
+export * from "./settings/paymentMethodIssuers.js";
+export * from "./settings/configuredLanguages.js";
+export * from "./mediaLibrary.js";
+export * from "./translations.js";

package/src/funcs/mediaLibrary.ts

@@ -0,0 +1,14 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import { encodeOperationQuery, executeOperation } from "../lib/operation.js";
+import * as operations from "../models/operations/index.js";
+
+export const mediaLibraryList = (client: ClientSDK, request: operations.ListMediaRequest = {}, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.list", method: "GET", path: () => "/media-library", requestSchema: operations.ListMediaRequest$outboundSchema, responseSchema: operations.ListMediaResponse$inboundSchema, query: (v) => encodeOperationQuery({}, { path: v.path }) }, options);
+export const mediaLibraryFoldersList = (client: ClientSDK, request: operations.ListMediaFoldersRequest = {}, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.listFolders", method: "GET", path: () => "/media-library/folders", requestSchema: operations.ListMediaFoldersRequest$outboundSchema, responseSchema: operations.ListMediaFoldersResponse$inboundSchema, query: (v) => encodeOperationQuery({}, { path: v.path }) }, options);
+export const mediaLibraryFoldersCreate = (client: ClientSDK, request: operations.CreateMediaFolderRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.createFolder", method: "POST", path: () => "/media-library/folders", requestSchema: operations.CreateMediaFolderRequest$outboundSchema, responseSchema: operations.CreateMediaFolderResponse$inboundSchema, body: (v) => v.data }, options);
+export const mediaLibraryUploadsPresign = (client: ClientSDK, request: operations.PresignMediaUploadRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.presignUpload", method: "POST", path: () => "/media-library/uploads/presign", requestSchema: operations.PresignMediaUploadRequest$outboundSchema, responseSchema: operations.PresignMediaUploadResponse$inboundSchema, body: (v) => v.data }, options);
+export const mediaLibraryItemsDelete = (client: ClientSDK, request: operations.DeleteMediaItemRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.deleteItem", method: "DELETE", path: () => "/media-library/items", requestSchema: operations.DeleteMediaItemRequest$outboundSchema, responseSchema: operations.DeleteMediaItemResponse$inboundSchema, body: (v) => v.data, responseType: "void", successStatus: 204 }, options);
+export const mediaLibraryItemsMove = (client: ClientSDK, request: operations.MoveMediaItemRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.moveItem", method: "PATCH", path: () => "/media-library/items/move", requestSchema: operations.MoveMediaItemRequest$outboundSchema, responseSchema: operations.MoveMediaItemResponse$inboundSchema, body: (v) => v.data, responseType: "void", successStatus: 204 }, options);
+export const mediaLibraryItemsRename = (client: ClientSDK, request: operations.RenameMediaItemRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.renameItem", method: "PATCH", path: () => "/media-library/items/rename", requestSchema: operations.RenameMediaItemRequest$outboundSchema, responseSchema: operations.RenameMediaItemResponse$inboundSchema, body: (v) => v.data }, options);
+export const mediaLibrarySearch = (client: ClientSDK, request: operations.SearchMediaRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.search", method: "GET", path: () => "/media-library/search", requestSchema: operations.SearchMediaRequest$outboundSchema, responseSchema: operations.SearchMediaResponse$inboundSchema, query: (v) => encodeOperationQuery({}, { q: v.q, path: v.path }) }, options);
+export const mediaLibrarySource = (client: ClientSDK, request: operations.GetMediaSourceRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.source", method: "GET", path: () => "/media-library/items/source", requestSchema: operations.GetMediaSourceRequest$outboundSchema, responseSchema: operations.GetMediaSourceResponse$inboundSchema, query: (v) => encodeOperationQuery({}, { path: v.path }), responseType: "bytes" }, options);
+export const mediaLibraryDownload = (client: ClientSDK, request: operations.DownloadMediaRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "mediaLibrary.download", method: "POST", path: () => "/media-library/downloads", requestSchema: operations.DownloadMediaRequest$outboundSchema, responseSchema: operations.DownloadMediaResponse$inboundSchema, body: (v) => v.data, responseType: "bytes" }, options);

package/src/funcs/settings/configuredLanguages.ts

@@ -0,0 +1,5 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { encodeOperationQuery, executeOperation } from "../../lib/operation.js";
+import * as operations from "../../models/operations/index.js";
+
+export const configuredLanguagesList = (client: ClientSDK, request: operations.ListConfiguredLanguagesRequest = {}, options?: RequestOptions) => executeOperation(client, request, { operationID: "settings.languages.list", method: "GET", path: () => "/settings/languages", requestSchema: operations.ListConfiguredLanguagesRequest$outboundSchema, responseSchema: operations.ListConfiguredLanguagesResponse$inboundSchema, query: (v) => encodeOperationQuery({ filter: v.filter }) }, options);

package/src/funcs/settings/customerGroups.ts

@@ -0,0 +1,6 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { encodeOperationQuery, executeOperation } from "../../lib/operation.js";
+import * as operations from "../../models/operations/index.js";
+
+export const settingCustomerGroupsList = (client: ClientSDK, request: operations.ListSettingCustomerGroupsRequest = {}, options?: RequestOptions) => executeOperation(client, request, { operationID: "settings.customerGroups.list", method: "GET", path: () => "/settings/customer-groups", requestSchema: operations.ListSettingCustomerGroupsRequest$outboundSchema, responseSchema: operations.ListSettingCustomerGroupsResponse$inboundSchema, query: encodeOperationQuery }, options);
+export const settingCustomerGroupsGet = (client: ClientSDK, request: operations.GetSettingCustomerGroupRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "settings.customerGroups.get", method: "GET", path: (v) => `/settings/customer-groups/${v.id}`, requestSchema: operations.GetSettingCustomerGroupRequest$outboundSchema, responseSchema: operations.GetSettingCustomerGroupResponse$inboundSchema, query: encodeOperationQuery }, options);

package/src/funcs/settings/index.ts

@@ -6,6 +6,9 @@ export * from "./countriesGet.js";
 export * from "./countriesList.js";
 export * from "./paymentMethodsGet.js";
 export * from "./paymentMethodsList.js";
+export * from "./customerGroups.js";
+export * from "./paymentMethodIssuers.js";
+export * from "./configuredLanguages.js";
 export * from "./socialProvidersGet.js";
 export * from "./socialProvidersList.js";
 export * from "./socialProvidersCreateLink.js";

package/src/funcs/settings/paymentMethodIssuers.ts

@@ -0,0 +1,6 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { encodeOperationQuery, executeOperation } from "../../lib/operation.js";
+import * as operations from "../../models/operations/index.js";
+
+export const paymentMethodIssuersList = (client: ClientSDK, request: operations.ListPaymentMethodIssuersRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "settings.paymentMethodIssuers.list", method: "GET", path: (v) => `/settings/paymentmethods/${v.methodId}/issuers`, requestSchema: operations.ListPaymentMethodIssuersRequest$outboundSchema, responseSchema: operations.ListPaymentMethodIssuersResponse$inboundSchema, query: encodeOperationQuery }, options);
+export const paymentMethodIssuersGet = (client: ClientSDK, request: operations.GetPaymentMethodIssuerRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "settings.paymentMethodIssuers.get", method: "GET", path: (v) => `/settings/paymentmethods/${v.methodId}/issuers/${v.id}`, requestSchema: operations.GetPaymentMethodIssuerRequest$outboundSchema, responseSchema: operations.GetPaymentMethodIssuerResponse$inboundSchema }, options);

package/src/funcs/translations.ts

@@ -0,0 +1,5 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import { executeOperation } from "../lib/operation.js";
+import * as operations from "../models/operations/index.js";
+
+export const translationsBulk = (client: ClientSDK, request: operations.BulkTranslateRequest, options?: RequestOptions) => executeOperation(client, request, { operationID: "translations.bulk", method: "POST", path: () => "/translations/bulk", requestSchema: operations.BulkTranslateRequest$outboundSchema, responseSchema: operations.BulkTranslateResponse$inboundSchema, body: (v) => v.data }, options);

package/src/index.ts

@@ -7,4 +7,6 @@ export * from "./core.js";
 export * from "./funcs/index.js";
 export * from "./sdk/modules.js";
 export * from "./sdk/sdk.js";
+export * from "./sdk/media-library.js";
+export * from "./sdk/translations.js";
 export * from "./sdk/tracking/index.js";

package/src/lib/config.ts

@@ -75,7 +75,7 @@ function applyApiVersion(url: URL, apiVersion: string | undefined): URL {
   return url;
 }
 
-export const SDK_VERSION = "1.4.3";
+export const SDK_VERSION = "1.4.4";
 
 export const SDK_METADATA = {
   language: "typescript",

package/src/lib/operation.ts

@@ -0,0 +1,198 @@
+import type * as z from "zod/v4";
+import { encodeDeepObjectQuery, encodeFormQuery, encodeJSON, queryJoin } from "./encodings.js";
+import * as M from "./matchers.js";
+import { safeParse } from "./schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "./security.js";
+import { ClientSDK, RequestOptions } from "./sdks.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/http-client-errors.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { OK, Result } from "../types/fp.js";
+import { applyPaginationParams, Paginated, PaginationParams } from "../models/pagination.js";
+
+export type OperationError =
+  | errors.ErrorResponse
+  | errors.OminityDefaultError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+export type OperationDefinition<Request, Response> = {
+  operationID: string;
+  method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+  path: (request: Request) => string;
+  requestSchema: z.ZodType<Request>;
+  responseSchema: z.ZodType<Response>;
+  query?: ((request: Request) => string | undefined) | undefined;
+  body?: ((request: Request) => unknown) | undefined;
+  responseType?: "json" | "bytes" | "stream" | "void" | undefined;
+  successStatus?: number | Array<number> | undefined;
+};
+
+export function encodeOperationQuery(request: {
+  include?: string | undefined;
+  sort?: string | undefined;
+  page?: number | undefined;
+  limit?: number | undefined;
+  filter?: Record<string, unknown> | undefined;
+}, extra: Record<string, unknown> = {}): string {
+  return queryJoin(
+    encodeFormQuery({
+      ...extra,
+      include: request.include,
+      sort: request.sort,
+      page: request.page,
+      limit: request.limit,
+    }),
+    request.filter ? encodeDeepObjectQuery({ filter: request.filter }) : undefined,
+  );
+}
+
+/**
+ * Executes a standard Ominity API operation while preserving the same
+ * validation, security, retry, error, and inspection lifecycle as generated
+ * endpoint functions.
+ */
+export function executeOperation<Request, Response>(
+  client: ClientSDK,
+  request: Request,
+  definition: OperationDefinition<Request, Response>,
+  options?: RequestOptions,
+): APIPromise<Result<Response, OperationError>> {
+  return new APIPromise(execute(client, request, definition, options));
+}
+
+async function execute<Request, Response>(
+  client: ClientSDK,
+  request: Request,
+  definition: OperationDefinition<Request, Response>,
+  options?: RequestOptions,
+): Promise<[Result<Response, OperationError>, APICall]> {
+  const parsed = safeParse(
+    request,
+    (value) => definition.requestSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+
+  const payload = parsed.value;
+  const responseType = definition.responseType ?? "json";
+  const headers = new Headers({
+    Accept: responseType === "json" ? "application/hal+json" : "*/*",
+  });
+  const bodyValue = definition.body?.(payload);
+  const body = typeof bodyValue === "undefined"
+    ? null
+    : encodeJSON("body", bodyValue, { explode: true });
+  if (body !== null) {
+    headers.set("Content-Type", "application/json");
+  }
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: definition.operationID,
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff" as const,
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 2,
+          maxElapsedTime: 7500,
+        },
+        retryConnectionErrors: true,
+      },
+    retryCodes: options?.retryCodes || ["5xx"],
+  };
+
+  const query = definition.query?.(payload);
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: definition.method,
+    baseURL: options?.serverURL,
+    path: definition.path(payload),
+    headers,
+    ...(typeof query === "undefined" ? {} : { query }),
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const status = definition.successStatus ?? (definition.method === "POST" ? [200, 201] : 200);
+  let successMatcher: M.ValueMatcher<Response>;
+  if (responseType === "bytes") {
+    successMatcher = M.bytes(status, definition.responseSchema, { ctype: "*" });
+  } else if (responseType === "stream") {
+    successMatcher = M.stream(status, definition.responseSchema, { ctype: "*" });
+  } else if (responseType === "void") {
+    successMatcher = M.nil(status, definition.responseSchema, { ctype: "*" });
+  } else {
+    successMatcher = M.json(status, definition.responseSchema);
+  }
+
+  const [result] = await M.match<Response, OperationError>(
+    successMatcher,
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema),
+    M.fail("5XX"),
+  )(response, req, {
+    extraFields: { HttpMeta: { Response: response, Request: req } },
+  });
+
+  if (result.ok && isPaginated(result.value)) {
+    return [
+      OK(applyPaginationParams(result.value, payload as PaginationParams) as Response),
+      { status: "complete", request: req, response },
+    ];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}
+
+function isPaginated(value: unknown): value is Paginated<unknown> {
+  return typeof value === "object"
+    && value !== null
+    && "items" in value
+    && Array.isArray(value.items)
+    && "count" in value
+    && typeof value.count === "number"
+    && "page" in value
+    && typeof value.page === "number"
+    && "limit" in value
+    && typeof value.limit === "number";
+}

package/src/models/cms/component-field.ts

@@ -0,0 +1,49 @@
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type ComponentFieldValidation = {
+  regex: string | null;
+  required: boolean;
+  min: number | null;
+  max: number | null;
+};
+
+export type ComponentField = {
+  resource: "component_field";
+  id: number;
+  name: string;
+  description: string;
+  type: string;
+  variant: string | null;
+  defaultValue: unknown;
+  isTranslatable: boolean;
+  validation: ComponentFieldValidation;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const ComponentFieldValidation$inboundSchema: z.ZodType<ComponentFieldValidation> = z.object({
+  regex: z.string().nullable(),
+  required: z.boolean(),
+  min: z.number().nullable(),
+  max: z.number().nullable(),
+});
+
+/** @internal */
+export const ComponentField$inboundSchema: z.ZodType<ComponentField> = z.object({
+  resource: z.literal("component_field"),
+  id: z.number().int(),
+  name: z.string(),
+  description: z.string(),
+  type: z.string(),
+  variant: z.string().nullable(),
+  defaultValue: z.unknown(),
+  isTranslatable: z.boolean(),
+  validation: ComponentFieldValidation$inboundSchema,
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => remap$(value, { _links: "links" }) as ComponentField);

package/src/models/cms/component.ts

@@ -7,11 +7,11 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
 
 export type Component = {
+    resource: "component";
     id: number;
     slug: string;
     name: string;
-    description: string;
-    type: string;
+    fields?: Array<unknown>;
     createdAt: string;
     updatedAt: string;
     links?: HalLinks;
@@ -19,18 +19,16 @@ export type Component = {
 
 /** @internal */
 export const Component$inboundSchema: z.ZodType<Component> = z.object({
+    resource: z.literal("component"),
     id: z.number(),
     slug: z.string(),
     name: z.string(),
-    description: z.string(),
-    type: z.string(),
-    created_at: z.string(),
-    updated_at: z.string(),
+    fields: z.array(z.unknown()).optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
     _links: HalLinks$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
-        "created_at": "createdAt",
-        "updated_at": "updatedAt",
         "_links": "links",
     }) as Component;
 });

package/src/models/cms/index.ts

@@ -1,8 +1,10 @@
 export * from "./component.js";
+export * from "./component-field.js";
 export * from "./layout.js";
 export * from "./page.js";
 export * from "./menu.js";
 export * from "./page-component.js";
+export * from "./page-component-field.js";
 export * from "./content-type-field.js";
 export * from "./content-type.js";
 export * from "./content-entry.js";

package/src/models/cms/page-component-field.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 PageComponentField = {
+  resource: "page_component_field";
+  id: number;
+  slug: string;
+  type: string;
+  pageComponentId: number;
+  componentFieldId: number;
+  value: unknown;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const PageComponentField$inboundSchema: z.ZodType<PageComponentField> = z.object({
+  resource: z.literal("page_component_field"),
+  id: z.number().int(),
+  slug: z.string(),
+  type: z.string(),
+  pageComponentId: z.number().int(),
+  componentFieldId: z.number().int(),
+  value: z.unknown(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => remap$(value, { _links: "links" }) as PageComponentField);

package/src/models/cms/page-component.ts

@@ -5,14 +5,16 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Component, Component$inboundSchema } from "./component.js";
+import { PageComponentField, PageComponentField$inboundSchema } from "./page-component-field.js";
 
 export type PageComponent = {
-    resource: string;
+    resource: "page_component";
     id: number;
     pageId: number;
     componentId: number;
-    order: number;
-    parameters: Record<string, any>;
+    component: Component;
+    fields: Record<string, PageComponentField>;
     createdAt: string;
     updatedAt: string;
     links?: HalLinks;
@@ -20,19 +22,17 @@ export type PageComponent = {
 
 /** @internal */
 export const PageComponent$inboundSchema: z.ZodType<PageComponent> = z.object({
-    resource: z.string(),
+    resource: z.literal("page_component"),
     id: z.number(),
     pageId: z.number(),
     componentId: z.number(),
-    order: z.number(),
-    parameters: z.record(z.string(), z.any()),
-    created_at: z.string(),
-    updated_at: z.string(),
+    component: Component$inboundSchema,
+    fields: z.record(z.string(), PageComponentField$inboundSchema),
+    createdAt: z.string(),
+    updatedAt: z.string(),
     _links: HalLinks$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
-        "created_at": "createdAt",
-        "updated_at": "updatedAt",
         "_links": "links",
     }) as PageComponent;
 });

package/src/models/commerce/address.ts

@@ -3,10 +3,15 @@
  */
 
 import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
 
 export type Address = {
-  firstName: string;
-  lastName: string;
+  resource?: "address" | undefined;
+  id?: number | undefined;
+  customerId?: number | undefined;
+  firstName: string | null;
+  lastName: string | null;
   street: string;
   number: string;
   additional: string;
@@ -14,12 +19,18 @@ export type Address = {
   city: string;
   region: string;
   country: string;
+  updatedAt?: string | undefined;
+  createdAt?: string | undefined;
+  links?: HalLinks | undefined;
 };
 
 /** @internal */
 export const Address$inboundSchema: z.ZodType<Address> = z.object({
-  firstName: z.string(),
-  lastName: z.string(),
+  resource: z.literal("address").optional(),
+  id: z.number().int().optional(),
+  customerId: z.number().int().optional(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
   street: z.string(),
   number: z.string(),
   additional: z.string(),
@@ -27,12 +38,18 @@ export const Address$inboundSchema: z.ZodType<Address> = z.object({
   city: z.string(),
   region: z.string(),
   country: z.string(),
-});
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => remap$(value, { _links: "links" }) as Address);
 
 /** @internal */
-export const Address$outboundSchema: z.ZodType<Address> = z.object({
-  firstName: z.string(),
-  lastName: z.string(),
+export const Address$outboundSchema = z.object({
+  resource: z.literal("address").optional(),
+  id: z.number().int().optional(),
+  customerId: z.number().int().optional(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
   street: z.string(),
   number: z.string(),
   additional: z.string(),
@@ -40,4 +57,7 @@ export const Address$outboundSchema: z.ZodType<Address> = z.object({
   city: z.string(),
   region: z.string(),
   country: z.string(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  links: HalLinks$inboundSchema.optional(),
 });

package/src/models/commerce/customer-group.ts

@@ -0,0 +1,28 @@
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type CustomerGroup = {
+  resource: "customer_group";
+  id: number;
+  name: string;
+  description: string | null;
+  color: string | null;
+  customFields?: Record<string, unknown> | Array<unknown>;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const CustomerGroup$inboundSchema: z.ZodType<CustomerGroup> = z.object({
+  resource: z.literal("customer_group"),
+  id: z.number().int(),
+  name: z.string(),
+  description: z.string().nullable(),
+  color: z.string().nullable(),
+  customFields: z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())]).optional(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((value) => remap$(value, { _links: "links" }) as CustomerGroup);

package/src/models/commerce/customer.ts

@@ -5,15 +5,22 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Address, Address$inboundSchema } from "./address.js";
 
 export type Customer = {
     resource: "customer";
     id: number;
     type: string;
-    name: string;
-    email: string;
+    name: string | null;
+    email: string | null;
+    phone: string | null;
+    companyVat: string | null;
+    billingAddress: Address | null;
+    shippingAddress: Address | null;
+    isTaxExempt: boolean;
     isGuest: boolean;
     ownerId: number | null;
+    customFields?: Record<string, unknown> | Array<unknown>;
     updatedAt: string;
     createdAt: string;
     links?: HalLinks;
@@ -24,10 +31,16 @@ export const Customer$inboundSchema: z.ZodType<Customer> = z.object({
     resource: z.literal("customer"),
     id: z.number().int(),
     type: z.string(),
-    name: z.string(),
-    email: z.string(),
+    name: z.string().nullable(),
+    email: z.string().nullable(),
+    phone: z.string().nullable(),
+    companyVat: z.string().nullable(),
+    billingAddress: Address$inboundSchema.nullable(),
+    shippingAddress: Address$inboundSchema.nullable(),
+    isTaxExempt: z.boolean(),
     isGuest: z.boolean(),
     ownerId: z.number().int().nullable(),
+    customFields: z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())]).optional(),
     updatedAt: z.string(),
     createdAt: z.string(),
     _links: HalLinks$inboundSchema.optional(),

package/src/models/commerce/index.ts

@@ -26,3 +26,7 @@ export * from "./customer-user-invitation.js";
 export * from "./customer.js";
 export * from "./customer-user-role.js";
 export * from "./customer-user-permission.js";
+export * from "./customer-group.js";
+export * from "./mandate.js";
+export * from "./subscription.js";
+export * from "./shipping-class.js";