@ominity/api-typescript 1.2.0 → 1.4.0

package/src/funcs/users/usersGetCustomer.ts

@@ -0,0 +1,164 @@
+/*
+ * Get a user customer membership.
+ */
+
+import { encodeFormQuery } from "../../lib/encodings.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as M from "../../lib/matchers.js";
+import { safeParse } from "../../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.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 * as operations from "../../models/operations/index.js";
+import { APICall, APIPromise } from "../../types/async.js";
+import { Result } from "../../types/fp.js";
+
+export function usersGetCustomer(
+  client: ClientSDK,
+  request: operations.GetUserCustomerRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.GetUserCustomerResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(client, request, options));
+}
+
+async function $do(
+  client: ClientSDK,
+  request: operations.GetUserCustomerRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.GetUserCustomerResponse,
+      | errors.ErrorResponse
+      | errors.OminityDefaultError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.GetUserCustomerRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const path = `/users/${payload.userId}/customers/${payload.customerId}`;
+  const query = encodeFormQuery({ include: payload.include });
+  const headers = new Headers({ Accept: "application/hal+json" });
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "users.customers.get",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 2,
+          maxElapsedTime: 7500,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["5xx"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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 responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    operations.GetUserCustomerResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, operations.GetUserCustomerResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}
+

package/src/funcs/users/usersListCustomers.ts

@@ -4,6 +4,7 @@
 
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import {
+    encodeDeepObjectQuery,
     encodeSimple,
     encodeFormQuery,
     queryJoin,
@@ -92,11 +93,17 @@ async function $do(
     ) || "";
 
     const baseQuery = encodeFormQuery({
+        include: payload.include,
+        sort: payload.sort,
         page: payload.page,
         limit: payload.limit,
     });
 
-    const query = queryJoin(baseQuery);
+    const filterQuery = payload.filter != null
+        ? encodeDeepObjectQuery({ filter: payload.filter })
+        : undefined;
+
+    const query = queryJoin(baseQuery, filterQuery);
 
     const headers = new Headers({
         Accept: "application/hal+json",

package/src/lib/config.ts

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

package/src/lib/sdks.ts

@@ -113,6 +113,14 @@ export class ClientSDK {
     }
   }
 
+  setLanguage(language: string | undefined): this {
+    this._options.language = language;
+    this._propagateLanguage(language);
+    return this;
+  }
+
+  protected _propagateLanguage(_language: string | undefined): void {}
+
   public _createRequest(
     context: HookContext,
     conf: RequestConfig,

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/cms-content.ts

@@ -9,7 +9,7 @@ import { HalLinks$inboundSchema } from "../hal.js";
 
 export type ListContentRequest = {
     slug: string;
-    filterId?: string | undefined;
+    filter?: Record<string, any> | undefined;
     sort?: string | undefined;
     page?: number | undefined;
     limit?: number | undefined;
@@ -22,7 +22,7 @@ export const ListContentRequest$outboundSchema: z.ZodType<
     ListContentRequest
 > = z.object({
     slug: z.string(),
-    filterId: z.string().optional(),
+    filter: z.record(z.string(), z.any()).optional(),
     sort: z.string().optional(),
     page: z.number().optional(),
     limit: z.number().optional(),

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;