@ominity/api-typescript 1.4.3 → 1.4.5

package/src/funcs/users/usersSendPasswordResetLink.ts

@@ -157,10 +157,10 @@ async function $do(
     | SDKValidationError
   >(
     M.json(200, SendPasswordResetLinkResponse$inboundSchema, {
-      ctype: "application/hal+json",
+      ctype: "application/json",
     }),
     M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
-      ctype: "application/hal+json",
+      ctype: "application/json",
     }),
     M.fail("5XX"),
   )(response, req, { extraFields: responseFields });

package/src/funcs/users/usersUpdate.ts

@@ -143,7 +143,7 @@ async function $do(
   >(
     M.json(200, User$inboundSchema, { ctype: "application/hal+json" }),
     M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
-      ctype: "application/hal+json",
+      ctype: "application/json",
     }),
     M.fail("5XX"),
   )(response, req, { extraFields: responseFields });

package/src/funcs/users/usersValidateMfa.ts

@@ -163,10 +163,10 @@ async function $do(
         | SDKValidationError
     >(
         M.json(200, ValidateMfaResponse$inboundSchema, {
-            ctype: "application/hal+json",
+            ctype: "application/json",
         }),
         M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
-            ctype: "application/hal+json",
+            ctype: "application/json",
         }),
         M.fail("5XX"),
     )(response, req, { extraFields: responseFields });

package/src/funcs/users/usersValidateRecoveryCode.ts

@@ -163,10 +163,10 @@ async function $do(
         | SDKValidationError
     >(
         M.json(200, ValidateRecoveryCodeResponse$inboundSchema, {
-            ctype: "application/hal+json",
+            ctype: "application/json",
         }),
         M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
-            ctype: "application/hal+json",
+            ctype: "application/json",
         }),
         M.fail("5XX"),
     )(response, req, { extraFields: responseFields });

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.5";
 
 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";

package/src/models/commerce/invoice.ts

@@ -23,12 +23,12 @@ export type InvoiceStatus = OpenEnum<typeof InvoiceStatus>;
 export type Invoice = {
     resource: string;
     id: number;
-    customerId: number;
+    customerId: number | null;
     number: string;
     status: InvoiceStatus;
     email: string;
-    companyName: string;
-    companyVat: string;
+    companyName: string | null;
+    companyVat: string | null;
     billingAddress: Address;
     subtotalAmount: CurrencyAmount;
     discountAmount: CurrencyAmount;
@@ -37,9 +37,9 @@ export type Invoice = {
     amountPaid: CurrencyAmount;
     isTaxExempt: boolean;
     notes: string;
-    invoicedAt: string;
-    dueAt: string;
-    paidAt: string;
+    invoicedAt: string | null;
+    dueAt: string | null;
+    paidAt: string | null;
     updatedAt: string;
     createdAt: string;
     links?: HalLinks;
@@ -53,12 +53,12 @@ export const InvoiceStatus$inboundSchema: z.ZodType<InvoiceStatus, unknown> = op
 export const Invoice$inboundSchema: z.ZodType<Invoice> = z.object({
     resource: z.string(),
     id: z.number(),
-    customerId: z.number(),
+    customerId: z.number().nullable(),
     number: z.string(),
     status: InvoiceStatus$inboundSchema,
     email: z.string(),
-    companyName: z.string(),
-    companyVat: z.string(),
+    companyName: z.string().nullable(),
+    companyVat: z.string().nullable(),
     billingAddress: Address$inboundSchema,
     subtotalAmount: CurrencyAmount$inboundSchema,
     discountAmount: CurrencyAmount$inboundSchema,
@@ -67,9 +67,9 @@ export const Invoice$inboundSchema: z.ZodType<Invoice> = z.object({
     amountPaid: CurrencyAmount$inboundSchema,
     isTaxExempt: z.boolean(),
     notes: z.string(),
-    invoicedAt: z.string(),
-    dueAt: z.string(),
-    paidAt: z.string(),
+    invoicedAt: z.string().nullable(),
+    dueAt: z.string().nullable(),
+    paidAt: z.string().nullable(),
     updatedAt: z.string(),
     createdAt: z.string(),
     _links: HalLinks$inboundSchema.optional(),