@ominity/api-typescript 1.3.0 → 1.4.1

package/src/lib/encodings.ts

@@ -343,6 +343,35 @@ export const encodeSimple = (
   return out.slice(1);
 };
 
+/**
+ * Replaces named placeholders in an API path with URL-encoded values.
+ *
+ * OpenAPI's `simple` encoder serializes one parameter value; it does not
+ * expand a complete path template. Generated operations should use this
+ * helper for paths such as `/users/{id}/customers`.
+ */
+export function encodePath(
+  template: string,
+  parameters: Readonly<Record<string, unknown>>,
+  options?: { explode?: boolean; charEncoding?: "percent" | "none" },
+): string {
+  const encodeString = (value: string) => {
+    return options?.charEncoding === "none" ? value : encodeURIComponent(value);
+  };
+
+  return template.replace(/\{([^{}]+)\}/g, (_placeholder, name: string) => {
+    const value = parameters[name];
+    if (value == null) {
+      throw new EncodingError(`Missing value for path parameter '${name}'.`);
+    }
+    if (Array.isArray(value) || isPlainObject(value)) {
+      throw new EncodingError(`Path parameter '${name}' must be a scalar value.`);
+    }
+
+    return encodeString(serializeValue(value));
+  });
+}
+
 function explode(key: string, value: unknown): [string, unknown][] {
   if (Array.isArray(value)) {
     return value.map((v) => [key, v]);

package/src/lib/sdks.ts

@@ -121,6 +121,21 @@ export class ClientSDK {
 
   protected _propagateLanguage(_language: string | undefined): void {}
 
+  private hookContext(context: HookContext): HookContext {
+    const operationOptions = typeof context.options === "object"
+      && context.options !== null
+      ? context.options
+      : {};
+
+    return {
+      ...context,
+      options: {
+        ...this._options,
+        ...operationOptions,
+      },
+    };
+  }
+
   public _createRequest(
     context: HookContext,
     conf: RequestConfig,
@@ -212,7 +227,7 @@ export class ClientSDK {
 
     let input;
     try {
-      input = this.#hooks.beforeCreateRequest(context, {
+      input = this.#hooks.beforeCreateRequest(this.hookContext(context), {
         url: reqURL,
         options: {
           ...fetchOptions,
@@ -249,7 +264,8 @@ export class ClientSDK {
       | UnexpectedClientError
     >
   > {
-    const { context, errorCodes } = options;
+    const { errorCodes } = options;
+    const context = this.hookContext(options.context);
 
     return retry(
       async () => {

package/src/models/commerce/customer-user-invitation.ts

@@ -0,0 +1,94 @@
+/*
+ * Customer user invitation model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type CustomerUserInvitationStatus = "pending" | "accepted" | "revoked" | "expired";
+
+export type CustomerUserInvitationCustomer = {
+  resource: "customer";
+  id: number;
+  name: string;
+};
+
+export type CustomerUserInvitationRole = {
+  resource: "customer_user_role";
+  id: number;
+  key: string;
+  name: string;
+  description: string;
+};
+
+export type CustomerUserInvitation = {
+  resource: "customer_user_invitation";
+  id: number;
+  customerId: number;
+  roleId: number;
+  channelId: number | null;
+  userId: number | null;
+  email: string;
+  existingUser: boolean;
+  requiresAccountCreation: boolean;
+  status: CustomerUserInvitationStatus;
+  expiresAt: string;
+  acceptedAt: string | null;
+  revokedAt: string | null;
+  customer?: CustomerUserInvitationCustomer;
+  role?: CustomerUserInvitationRole;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const CustomerUserInvitation$inboundSchema: z.ZodType<CustomerUserInvitation> = z.object({
+  resource: z.literal("customer_user_invitation"),
+  id: z.number().int(),
+  customerId: z.number().int(),
+  roleId: z.number().int(),
+  channelId: z.number().int().nullable(),
+  userId: z.number().int().nullable(),
+  email: z.string(),
+  existingUser: z.boolean(),
+  requiresAccountCreation: z.boolean(),
+  status: z.enum(["pending", "accepted", "revoked", "expired"]),
+  expiresAt: z.string(),
+  acceptedAt: z.string().nullable(),
+  revokedAt: z.string().nullable(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    customer: z.object({
+      resource: z.literal("customer"),
+      id: z.number().int(),
+      name: z.string(),
+    }).loose().optional(),
+    role: z.object({
+      resource: z.literal("customer_user_role"),
+      id: z.number().int(),
+      key: z.string(),
+      name: z.string(),
+      description: z.string(),
+    }).loose().optional(),
+  }).loose().optional(),
+}).loose().transform((value) => {
+  const embedded = value._embedded;
+  const invitation = remap$(value, {
+    "_links": "links",
+    "_embedded": null,
+  }) as CustomerUserInvitation;
+
+  if (embedded?.customer) {
+    invitation.customer = embedded.customer;
+  }
+
+  if (embedded?.role) {
+    invitation.role = embedded.role;
+  }
+
+  return invitation;
+}) as unknown as z.ZodType<CustomerUserInvitation>;

package/src/models/commerce/customer-user-permission.ts

@@ -0,0 +1,52 @@
+/*
+ * Customer user permission catalogue models.
+ */
+
+import * as z from "zod/v4";
+
+export type CustomerUserPermissionGroup = {
+    key: string;
+    label: string;
+    description: string | null;
+    icon: string | null;
+    order: number;
+};
+
+export type CustomerUserPermission = {
+    key: string;
+    label: string;
+    description: string | null;
+    group: string | null;
+    icon: string | null;
+};
+
+export type CustomerUserPermissionCatalog = {
+    resource: "customer_user_permission_catalog";
+    groups: Array<CustomerUserPermissionGroup>;
+    permissions: Array<CustomerUserPermission>;
+};
+
+/** @internal */
+export const CustomerUserPermissionGroup$inboundSchema: z.ZodType<CustomerUserPermissionGroup> = z.object({
+    key: z.string(),
+    label: z.string(),
+    description: z.string().nullable(),
+    icon: z.string().nullable(),
+    order: z.number().int(),
+});
+
+/** @internal */
+export const CustomerUserPermission$inboundSchema: z.ZodType<CustomerUserPermission> = z.object({
+    key: z.string(),
+    label: z.string(),
+    description: z.string().nullable(),
+    group: z.string().nullable(),
+    icon: z.string().nullable(),
+});
+
+/** @internal */
+export const CustomerUserPermissionCatalog$inboundSchema: z.ZodType<CustomerUserPermissionCatalog> = z.object({
+    resource: z.literal("customer_user_permission_catalog"),
+    groups: z.array(CustomerUserPermissionGroup$inboundSchema),
+    permissions: z.array(CustomerUserPermission$inboundSchema),
+});

package/src/models/commerce/customer-user-role.ts

@@ -0,0 +1,42 @@
+/*
+ * Customer user role model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type CustomerUserRole = {
+    resource: "customer_user_role";
+    id: number;
+    key: string;
+    name: string;
+    description: string;
+    nameTranslations: Record<string, string>;
+    descriptionTranslations: Record<string, string | null>;
+    permissions: Array<string>;
+    isSystem: boolean;
+    isAssignable: boolean;
+    updatedAt: string;
+    createdAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const CustomerUserRole$inboundSchema: z.ZodType<CustomerUserRole> = z.object({
+    resource: z.literal("customer_user_role"),
+    id: z.number().int(),
+    key: z.string(),
+    name: z.string(),
+    description: z.string(),
+    nameTranslations: z.record(z.string(), z.string()),
+    descriptionTranslations: z.record(z.string(), z.string().nullable()),
+    permissions: z.array(z.string()),
+    isSystem: z.boolean(),
+    isAssignable: z.boolean(),
+    updatedAt: z.string(),
+    createdAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((v) => remap$(v, {
+    "_links": "links",
+}) as CustomerUserRole);

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

@@ -5,16 +5,22 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Customer, Customer$inboundSchema } from "./customer.js";
+import { CustomerUserRole, CustomerUserRole$inboundSchema } from "./customer-user-role.js";
 
 export type CustomerUser = {
     resource: "customer_user";
     userId: number;
     customerId: number;
     roleId: number;
+    isOwner: boolean;
+    permissions: Array<string>;
     firstName: string;
     lastName: string;
     email: string;
     avatar?: string | null;
+    customer?: Customer;
+    role?: CustomerUserRole;
     updatedAt: string;
     createdAt: string;
     links?: HalLinks;
@@ -26,6 +32,8 @@ export const CustomerUser$inboundSchema: z.ZodType<CustomerUser> = z.object({
     userId: z.number().int(),
     customerId: z.number().int(),
     roleId: z.number().int(),
+    isOwner: z.boolean(),
+    permissions: z.array(z.string()),
     firstName: z.string(),
     lastName: z.string(),
     email: z.string(),
@@ -33,8 +41,24 @@ export const CustomerUser$inboundSchema: z.ZodType<CustomerUser> = z.object({
     updatedAt: z.string(),
     createdAt: z.string(),
     _links: HalLinks$inboundSchema.optional(),
+    _embedded: z.object({
+        customer: Customer$inboundSchema.optional(),
+        role: CustomerUserRole$inboundSchema.optional(),
+    }).loose().optional(),
 }).loose().transform((v) => {
-    return remap$(v, {
+    const embedded = v._embedded;
+    const customerUser = remap$(v, {
         "_links": "links",
+        "_embedded": null,
     }) as CustomerUser;
-});
+
+    if (embedded?.role) {
+        customerUser.role = embedded.role;
+    }
+
+    if (embedded?.customer) {
+        customerUser.customer = embedded.customer;
+    }
+
+    return customerUser;
+}) as unknown as z.ZodType<CustomerUser>;

package/src/models/commerce/customer.ts

@@ -0,0 +1,36 @@
+/*
+ * Commerce customer model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type Customer = {
+    resource: "customer";
+    id: number;
+    type: string;
+    name: string;
+    email: string;
+    isGuest: boolean;
+    ownerId: number | null;
+    updatedAt: string;
+    createdAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+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(),
+    isGuest: z.boolean(),
+    ownerId: z.number().int().nullable(),
+    updatedAt: z.string(),
+    createdAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((v) => remap$(v, {
+    "_links": "links",
+}) as Customer);

package/src/models/commerce/index.ts

@@ -21,3 +21,8 @@ export * from "./shipping-method.js";
 export * from "./shipping-zone.js";
 export * from "./review.js";
 export * from "./currency.js";
+export * from "./customer-user.js";
+export * from "./customer-user-invitation.js";
+export * from "./customer.js";
+export * from "./customer-user-role.js";
+export * from "./customer-user-permission.js";

package/src/models/operations/commerce-customer-user-invitations.ts

@@ -0,0 +1,139 @@
+/*
+ * Commerce customer user invitation operations.
+ */
+
+import * as z from "zod/v4";
+import {
+  CustomerUserInvitation,
+  CustomerUserInvitation$inboundSchema,
+} from "../commerce/customer-user-invitation.js";
+import { CustomerUser, CustomerUser$inboundSchema } from "../commerce/customer-user.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+
+const invitationAcceptUrlSchema = z.string().refine((value) => {
+  try {
+    const url = new URL(value.replaceAll("{token}", "invitation-token"));
+
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}, "Invalid invitation acceptance URL");
+
+export type CreateCustomerUserInvitationRequest = {
+  customerId: number;
+  data: {
+    email: string;
+    roleId: number;
+    acceptUrl: string;
+    language?: string | null | undefined;
+  };
+};
+export type CreateCustomerUserInvitationResponse = CustomerUserInvitation;
+
+/** @internal */
+export const CreateCustomerUserInvitationRequest$outboundSchema: z.ZodType<CreateCustomerUserInvitationRequest> = z.object({
+  customerId: z.number().int(),
+  data: z.object({
+    email: z.string().email(),
+    roleId: z.number().int(),
+    acceptUrl: invitationAcceptUrlSchema,
+    language: z.string().nullable().optional(),
+  }),
+});
+/** @internal */
+export const CreateCustomerUserInvitationResponse$inboundSchema: z.ZodType<CreateCustomerUserInvitationResponse> = CustomerUserInvitation$inboundSchema;
+
+export type ListCustomerUserInvitationsRequest = {
+  customerId: number;
+  filter?: {
+    id?: number | undefined;
+    email?: string | undefined;
+    role?: number | undefined;
+  } | undefined;
+  sort?: string | undefined;
+  page?: number | undefined;
+  limit?: number | undefined;
+};
+export type ListCustomerUserInvitationsResponse = Paginated<CustomerUserInvitation>;
+
+/** @internal */
+export const ListCustomerUserInvitationsRequest$outboundSchema: z.ZodType<ListCustomerUserInvitationsRequest> = z.object({
+  customerId: z.number().int(),
+  filter: z.object({
+    id: z.number().int().optional(),
+    email: z.string().optional(),
+    role: z.number().int().optional(),
+  }).optional(),
+  sort: z.string().optional(),
+  page: z.number().optional(),
+  limit: z.number().optional(),
+});
+
+/** @internal */
+export const ListCustomerUserInvitationsResponse$inboundSchema: z.ZodType<ListCustomerUserInvitationsResponse> = z.object({
+  _embedded: z.object({
+    customer_user_invitations: z.array(CustomerUserInvitation$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((value) => buildPaginated(
+  value._embedded.customer_user_invitations,
+  value.count,
+  value._links,
+));
+
+export type GetCustomerUserInvitationRequest = {
+  customerId: number;
+  id: number;
+};
+export type GetCustomerUserInvitationResponse = CustomerUserInvitation;
+
+/** @internal */
+export const GetCustomerUserInvitationRequest$outboundSchema: z.ZodType<GetCustomerUserInvitationRequest> = z.object({
+  customerId: z.number().int(),
+  id: z.number().int(),
+});
+/** @internal */
+export const GetCustomerUserInvitationResponse$inboundSchema: z.ZodType<GetCustomerUserInvitationResponse> = CustomerUserInvitation$inboundSchema;
+
+export type RevokeCustomerUserInvitationRequest = {
+  customerId: number;
+  id: number;
+};
+export type RevokeCustomerUserInvitationResponse = void;
+
+/** @internal */
+export const RevokeCustomerUserInvitationRequest$outboundSchema: z.ZodType<RevokeCustomerUserInvitationRequest> = z.object({
+  customerId: z.number().int(),
+  id: z.number().int(),
+});
+/** @internal */
+export const RevokeCustomerUserInvitationResponse$inboundSchema: z.ZodType<RevokeCustomerUserInvitationResponse> = z.void();
+
+export type InspectCustomerUserInvitationRequest = {
+  token: string;
+};
+export type InspectCustomerUserInvitationResponse = CustomerUserInvitation;
+
+/** @internal */
+export const InspectCustomerUserInvitationRequest$outboundSchema: z.ZodType<InspectCustomerUserInvitationRequest> = z.object({
+  token: z.string().min(1),
+});
+/** @internal */
+export const InspectCustomerUserInvitationResponse$inboundSchema: z.ZodType<InspectCustomerUserInvitationResponse> = CustomerUserInvitation$inboundSchema;
+
+export type AcceptCustomerUserInvitationRequest = {
+  token: string;
+  userId?: number | undefined;
+};
+export type AcceptCustomerUserInvitationResponse = CustomerUser;
+
+/** @internal */
+export const AcceptCustomerUserInvitationRequest$outboundSchema: z.ZodType<AcceptCustomerUserInvitationRequest> = z.object({
+  token: z.string().length(64),
+  userId: z.number().int().optional(),
+});
+/** @internal */
+export const AcceptCustomerUserInvitationResponse$inboundSchema: z.ZodType<AcceptCustomerUserInvitationResponse> = CustomerUser$inboundSchema;

package/src/models/operations/commerce-customer-user-permissions.ts

@@ -0,0 +1,17 @@
+/*
+ * Commerce customer user permission operations.
+ */
+
+import * as z from "zod/v4";
+import {
+    CustomerUserPermissionCatalog,
+    CustomerUserPermissionCatalog$inboundSchema,
+} from "../commerce/customer-user-permission.js";
+
+export type ListCustomerUserPermissionsRequest = Record<string, never>;
+export type ListCustomerUserPermissionsResponse = CustomerUserPermissionCatalog;
+
+/** @internal */
+export const ListCustomerUserPermissionsRequest$outboundSchema: z.ZodType<ListCustomerUserPermissionsRequest> = z.object({});
+/** @internal */
+export const ListCustomerUserPermissionsResponse$inboundSchema: z.ZodType<ListCustomerUserPermissionsResponse> = CustomerUserPermissionCatalog$inboundSchema;

package/src/models/operations/commerce-customer-user-roles.ts

@@ -0,0 +1,96 @@
+/*
+ * Commerce customer user role operations.
+ */
+
+import * as z from "zod/v4";
+import { CustomerUserRole, CustomerUserRole$inboundSchema } from "../commerce/customer-user-role.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+
+export type CustomerUserRoleData = {
+    key: string;
+    name: Record<string, string>;
+    description?: Record<string, string | null> | undefined;
+    permissions: Array<string>;
+    isAssignable?: boolean | undefined;
+};
+
+export type ListCustomerUserRolesRequest = {
+    page?: number | undefined;
+    limit?: number | undefined;
+};
+export type ListCustomerUserRolesResponse = Paginated<CustomerUserRole>;
+
+/** @internal */
+export const ListCustomerUserRolesRequest$outboundSchema: z.ZodType<ListCustomerUserRolesRequest> = z.object({
+    page: z.number().optional(),
+    limit: z.number().optional(),
+});
+/** @internal */
+export const ListCustomerUserRolesResponse$inboundSchema: z.ZodType<ListCustomerUserRolesResponse> = z.object({
+    _embedded: z.object({
+        customer_user_roles: z.array(CustomerUserRole$inboundSchema),
+    }),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => buildPaginated(v._embedded.customer_user_roles, v.count, v._links));
+
+export type GetCustomerUserRoleRequest = { id: number };
+export type GetCustomerUserRoleResponse = CustomerUserRole;
+
+/** @internal */
+export const GetCustomerUserRoleRequest$outboundSchema: z.ZodType<GetCustomerUserRoleRequest> = z.object({
+    id: z.number().int(),
+});
+/** @internal */
+export const GetCustomerUserRoleResponse$inboundSchema: z.ZodType<GetCustomerUserRoleResponse> = CustomerUserRole$inboundSchema;
+
+export type CreateCustomerUserRoleRequest = CustomerUserRoleData;
+export type CreateCustomerUserRoleResponse = CustomerUserRole;
+
+/** @internal */
+export const CreateCustomerUserRoleRequest$outboundSchema: z.ZodType<CreateCustomerUserRoleRequest> = z.object({
+    key: z.string(),
+    name: z.record(z.string(), z.string()),
+    description: z.record(z.string(), z.string().nullable()).optional(),
+    permissions: z.array(z.string()),
+    isAssignable: z.boolean().optional(),
+});
+/** @internal */
+export const CreateCustomerUserRoleResponse$inboundSchema: z.ZodType<CreateCustomerUserRoleResponse> = CustomerUserRole$inboundSchema;
+
+export type UpdateCustomerUserRoleRequest = {
+    id: number;
+    data: {
+        key?: string | undefined;
+        name?: Record<string, string> | undefined;
+        description?: Record<string, string | null> | undefined;
+        permissions?: Array<string> | undefined;
+        isAssignable?: boolean | undefined;
+    };
+};
+export type UpdateCustomerUserRoleResponse = CustomerUserRole;
+
+/** @internal */
+export const UpdateCustomerUserRoleRequest$outboundSchema: z.ZodType<UpdateCustomerUserRoleRequest> = z.object({
+    id: z.number().int(),
+    data: z.object({
+        key: z.string().optional(),
+        name: z.record(z.string(), z.string()).optional(),
+        description: z.record(z.string(), z.string().nullable()).optional(),
+        permissions: z.array(z.string()).optional(),
+        isAssignable: z.boolean().optional(),
+    }),
+});
+/** @internal */
+export const UpdateCustomerUserRoleResponse$inboundSchema: z.ZodType<UpdateCustomerUserRoleResponse> = CustomerUserRole$inboundSchema;
+
+export type DeleteCustomerUserRoleRequest = { id: number };
+export type DeleteCustomerUserRoleResponse = void;
+
+/** @internal */
+export const DeleteCustomerUserRoleRequest$outboundSchema: z.ZodType<DeleteCustomerUserRoleRequest> = z.object({
+    id: z.number().int(),
+});
+/** @internal */
+export const DeleteCustomerUserRoleResponse$inboundSchema: z.ZodType<DeleteCustomerUserRoleResponse> = z.void();