@ominity/api-typescript 1.3.0 → 1.4.0

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

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

@@ -0,0 +1,88 @@
+/*
+ * Commerce customer user membership operations.
+ */
+
+import * as z from "zod/v4";
+import { CustomerUser, CustomerUser$inboundSchema } from "../commerce/customer-user.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+
+export type ListCustomerUsersRequest = {
+    customerId: number;
+    filter?: {
+        id?: number | undefined;
+    } | undefined;
+    sort?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+};
+
+export type ListCustomerUsersResponse = Paginated<CustomerUser>;
+
+/** @internal */
+export const ListCustomerUsersRequest$outboundSchema: z.ZodType<ListCustomerUsersRequest> = z.object({
+    customerId: z.number().int(),
+    filter: z.object({
+        id: z.number().int().optional(),
+    }).optional(),
+    sort: z.string().optional(),
+    page: z.number().optional(),
+    limit: z.number().optional(),
+});
+
+/** @internal */
+export const ListCustomerUsersResponse$inboundSchema: z.ZodType<ListCustomerUsersResponse> = z.object({
+    _embedded: z.object({
+        customer_users: z.array(CustomerUser$inboundSchema),
+    }),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => buildPaginated(v._embedded.customer_users, v.count, v._links));
+
+export type GetCustomerUserRequest = {
+    customerId: number;
+    userId: number;
+};
+export type GetCustomerUserResponse = CustomerUser;
+
+/** @internal */
+export const GetCustomerUserRequest$outboundSchema: z.ZodType<GetCustomerUserRequest> = z.object({
+    customerId: z.number().int(),
+    userId: z.number().int(),
+});
+/** @internal */
+export const GetCustomerUserResponse$inboundSchema: z.ZodType<GetCustomerUserResponse> = CustomerUser$inboundSchema;
+
+export type UpdateCustomerUserRequest = {
+    customerId: number;
+    userId: number;
+    data: {
+        roleId: number;
+    };
+};
+export type UpdateCustomerUserResponse = CustomerUser;
+
+/** @internal */
+export const UpdateCustomerUserRequest$outboundSchema: z.ZodType<UpdateCustomerUserRequest> = z.object({
+    customerId: z.number().int(),
+    userId: z.number().int(),
+    data: z.object({
+        roleId: z.number().int(),
+    }),
+});
+/** @internal */
+export const UpdateCustomerUserResponse$inboundSchema: z.ZodType<UpdateCustomerUserResponse> = CustomerUser$inboundSchema;
+
+export type DeleteCustomerUserRequest = {
+    customerId: number;
+    userId: number;
+};
+export type DeleteCustomerUserResponse = void;
+
+/** @internal */
+export const DeleteCustomerUserRequest$outboundSchema: z.ZodType<DeleteCustomerUserRequest> = z.object({
+    customerId: z.number().int(),
+    userId: z.number().int(),
+});
+/** @internal */
+export const DeleteCustomerUserResponse$inboundSchema: z.ZodType<DeleteCustomerUserResponse> = z.void();

package/src/models/operations/index.ts

@@ -18,6 +18,10 @@ export * from "./commerce-shipping-methods.js";
 export * from "./commerce-shipping-zones.js";
 export * from "./commerce-reviews.js";
 export * from "./commerce-currencies.js";
+export * from "./commerce-customer-users.js";
+export * from "./commerce-customer-user-invitations.js";
+export * from "./commerce-customer-user-roles.js";
+export * from "./commerce-customer-user-permissions.js";
 export * from "./settings-countries.js";
 export * from "./settings-social-providers.js";
 export * from "./settings-payment-methods.js";

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

@@ -12,6 +12,22 @@ export type ListUserCustomersRequest = {
      * User ID.
      */
     id: number;
+    /**
+     * Include related customer or role resources.
+     */
+    include?: string | undefined;
+    /**
+     * Filter by membership, role, or customer fields.
+     */
+    filter?: {
+        id?: number | undefined;
+        role?: number | undefined;
+        customer?: number | undefined;
+    } | undefined;
+    /**
+     * Sort by membership fields.
+     */
+    sort?: string | undefined;
     /**
      * Page number.
      */
@@ -29,6 +45,13 @@ export const ListUserCustomersRequest$outboundSchema: z.ZodType<
     ListUserCustomersRequest
 > = z.object({
     id: z.number(),
+    include: z.string().optional(),
+    filter: z.object({
+        id: z.number().int().optional(),
+        role: z.number().int().optional(),
+        customer: z.number().int().optional(),
+    }).optional(),
+    sort: z.string().optional(),
     page: z.number().optional(),
     limit: z.number().optional(),
 });
@@ -49,3 +72,21 @@ export const ListUserCustomersResponse$inboundSchema: z.ZodType<
         v._links,
     )
 );
+
+export type GetUserCustomerRequest = {
+    userId: number;
+    customerId: number;
+    include?: string | undefined;
+};
+
+export type GetUserCustomerResponse = CustomerUser;
+
+/** @internal */
+export const GetUserCustomerRequest$outboundSchema: z.ZodType<GetUserCustomerRequest> = z.object({
+    userId: z.number().int(),
+    customerId: z.number().int(),
+    include: z.string().optional(),
+});
+
+/** @internal */
+export const GetUserCustomerResponse$inboundSchema: z.ZodType<GetUserCustomerResponse> = CustomerUser$inboundSchema;

package/src/sdk/commerce/customer-user-invitations.ts

@@ -0,0 +1,59 @@
+/*
+ * Commerce customer user invitations SDK.
+ */
+
+import {
+  customerUserInvitationsAccept,
+  customerUserInvitationsCreate,
+  customerUserInvitationsGet,
+  customerUserInvitationsInspect,
+  customerUserInvitationsList,
+  customerUserInvitationsRevoke,
+} from "../../funcs/commerce/index.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export class CustomerUserInvitations extends ClientSDK {
+  async create(
+    request: operations.CreateCustomerUserInvitationRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateCustomerUserInvitationResponse> {
+    return unwrapAsync(customerUserInvitationsCreate(this, request, options));
+  }
+
+  async list(
+    request: operations.ListCustomerUserInvitationsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ListCustomerUserInvitationsResponse> {
+    return unwrapAsync(customerUserInvitationsList(this, request, options));
+  }
+
+  async get(
+    request: operations.GetCustomerUserInvitationRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetCustomerUserInvitationResponse> {
+    return unwrapAsync(customerUserInvitationsGet(this, request, options));
+  }
+
+  async revoke(
+    request: operations.RevokeCustomerUserInvitationRequest,
+    options?: RequestOptions,
+  ): Promise<operations.RevokeCustomerUserInvitationResponse> {
+    return unwrapAsync(customerUserInvitationsRevoke(this, request, options));
+  }
+
+  async inspect(
+    request: operations.InspectCustomerUserInvitationRequest,
+    options?: RequestOptions,
+  ): Promise<operations.InspectCustomerUserInvitationResponse> {
+    return unwrapAsync(customerUserInvitationsInspect(this, request, options));
+  }
+
+  async accept(
+    request: operations.AcceptCustomerUserInvitationRequest,
+    options?: RequestOptions,
+  ): Promise<operations.AcceptCustomerUserInvitationResponse> {
+    return unwrapAsync(customerUserInvitationsAccept(this, request, options));
+  }
+}

package/src/sdk/commerce/customer-user-permissions.ts

@@ -0,0 +1,16 @@
+/*
+ * Commerce customer user permissions SDK.
+ */
+
+import { customerUserPermissionsList } from "../../funcs/commerce/index.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export class CustomerUserPermissions extends ClientSDK {
+  async list(
+    options?: RequestOptions,
+  ): Promise<operations.ListCustomerUserPermissionsResponse> {
+    return unwrapAsync(customerUserPermissionsList(this, {}, options));
+  }
+}