@ominity/api-typescript 0.0.1 → 0.0.2

package/src/models/commerce/cart.ts

@@ -0,0 +1,128 @@
+/*
+ * Cart model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Address, Address$inboundSchema } from "./address.js";
+import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { CartItem, CartItem$inboundSchema } from "./cart-item.js";
+
+export const CartStatus = {
+  Open: "open",
+  Completed: "completed",
+  Abandoned: "abandoned",
+  Expired: "expired",
+} as const;
+export type CartStatus = OpenEnum<typeof CartStatus>;
+
+export const CartType = {
+  Shared: "shared",
+  Default: "default",
+} as const;
+export type CartType = OpenEnum<typeof CartType>;
+
+export type Cart = {
+  resource: string;
+  id: string;
+  status: CartStatus;
+  type: CartType;
+  channelId?: number;
+  languageId?: number | null;
+  customerId?: number | null;
+  userId?: number | null;
+  email?: string;
+  companyName?: string;
+  companyVat?: string;
+  billingAddress?: Address;
+  shippingAddress?: Address;
+  subtotalAmount?: CurrencyAmount;
+  shippingAmount?: CurrencyAmount;
+  discountAmount?: CurrencyAmount;
+  taxAmount?: CurrencyAmount;
+  totalAmount?: CurrencyAmount;
+  country?: string;
+  currency?: string;
+  isShippingRequired?: boolean;
+  shippingMethodId?: number | null;
+  isTaxExempt?: boolean;
+  items?: CartItem[];
+  itemsCount?: number;
+  itemsExists?: boolean;
+  shippingMethod?: unknown;
+  shippingMethodCount?: number;
+  shippingMethodExists?: boolean;
+  totalQuantity?: number;
+  promotionCodes?: string[];
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const CartStatus$inboundSchema: z.ZodType<CartStatus, unknown> = openEnums
+  .inboundSchema(CartStatus);
+/** @internal */
+export const CartType$inboundSchema: z.ZodType<CartType, unknown> = openEnums
+  .inboundSchema(CartType);
+
+/** @internal */
+export const Cart$inboundSchema: z.ZodType<Cart> = z.object({
+  resource: z.string(),
+  id: z.string(),
+  status: CartStatus$inboundSchema,
+  type: CartType$inboundSchema,
+  channelId: z.number().optional(),
+  languageId: z.number().nullable().optional(),
+  customerId: z.number().nullable().optional(),
+  userId: z.number().nullable().optional(),
+  email: z.string().optional(),
+  companyName: z.string().optional(),
+  companyVat: z.string().optional(),
+  billingAddress: Address$inboundSchema.optional(),
+  shippingAddress: Address$inboundSchema.optional(),
+  subtotalAmount: CurrencyAmount$inboundSchema.optional(),
+  shippingAmount: CurrencyAmount$inboundSchema.optional(),
+  discountAmount: CurrencyAmount$inboundSchema.optional(),
+  taxAmount: CurrencyAmount$inboundSchema.optional(),
+  totalAmount: CurrencyAmount$inboundSchema.optional(),
+  country: z.string().optional(),
+  currency: z.string().optional(),
+  isShippingRequired: z.boolean().optional(),
+  shippingMethodId: z.number().nullable().optional(),
+  isTaxExempt: z.boolean().optional(),
+  items: z.array(CartItem$inboundSchema).optional(),
+  itemsCount: z.number().optional(),
+  itemsExists: z.boolean().optional(),
+  shippingMethod: z.any().optional(),
+  shippingMethodCount: z.number().optional(),
+  shippingMethodExists: z.boolean().optional(),
+  totalQuantity: z.number().optional(),
+  promotionCodes: z.array(z.string()).optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => remap$(v, { _links: "links" }) as Cart);
+
+export type CartsListResponse = Paginated<Cart>;
+
+/** @internal */
+export const CartsListResponse$inboundSchema: z.ZodType<
+  CartsListResponse
+> = z.object({
+  _embedded: z.object({
+    carts: z.array(Cart$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(
+    v._embedded.carts,
+    v.count,
+    v._links,
+  )
+);

package/src/models/commerce/category.ts

@@ -0,0 +1,87 @@
+/*
+ * Category model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Tag, Tag$inboundSchema } from "../common/tag.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Route, Route$inboundSchema } from "./route.js";
+
+export type Category = {
+  resource: string;
+  id: number;
+  parentId: number | null;
+  name: string;
+  slug: string;
+  fullSlug: string;
+  description: string;
+  coverImage: string | null;
+  routes: Record<string, Route>;
+  productsCount: number;
+  customFields: unknown[];
+  updatedAt: string;
+  createdAt: string;
+  parent?: Category;
+  children?: Category[];
+  tags?: Tag[];
+  links?: HalLinks;
+};
+
+export type CategoriesListResponse = Paginated<Category>;
+
+/** @internal */
+export const Category$inboundSchema: z.ZodType<Category> = z.object({
+  resource: z.string(),
+  id: z.number(),
+  parentId: z.number().nullable(),
+  name: z.string(),
+  slug: z.string(),
+  fullSlug: z.string(),
+  description: z.string(),
+  coverImage: z.string().nullable(),
+  routes: z.record(z.string(), Route$inboundSchema),
+  productsCount: z.number(),
+  customFields: z.array(z.any()),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    parent: z.lazy(() => Category$inboundSchema).optional(),
+    children: z.array(z.lazy(() => Category$inboundSchema)).optional(),
+    tags: z.array(Tag$inboundSchema).optional(),
+  }).loose().optional(),
+}).transform((v) => {
+  const { _embedded } = v;
+  const remapped = remap$(v, { _links: "links", _embedded: null });
+
+  if (_embedded?.parent !== undefined) {
+    (remapped as Category).parent = _embedded.parent;
+  }
+  if (_embedded?.children !== undefined) {
+    (remapped as Category).children = _embedded.children;
+  }
+  if (_embedded?.tags !== undefined) {
+    (remapped as Category).tags = _embedded.tags;
+  }
+
+  return remapped as Category;
+});
+
+/** @internal */
+export const CategoriesListResponse$inboundSchema: z.ZodType<
+  Paginated<Category>
+> = z.object({
+  _embedded: z.object({
+    categories: z.array(Category$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(
+    v._embedded.categories,
+    v.count,
+    v._links,
+  )
+);

package/src/models/commerce/index.ts

@@ -0,0 +1,13 @@
+/*
+ * Commerce models.
+ */
+
+export * from "./product.js";
+export * from "./category.js";
+export * from "./product-group.js";
+export * from "./product-offer.js";
+export * from "./cart.js";
+export * from "./cart-item.js";
+export * from "./address.js";
+export * from "./money.js";
+export * from "./route.js";

package/src/models/commerce/money.ts

@@ -0,0 +1,24 @@
+/*
+ * Money model.
+ */
+
+import * as z from "zod/v4";
+
+export type Money = {
+  amount: number;
+  formatted: string;
+};
+
+export type PriceMap = Record<string, Money>;
+
+/** @internal */
+export const Money$inboundSchema: z.ZodType<Money> = z.object({
+  amount: z.number(),
+  formatted: z.string(),
+});
+
+/** @internal */
+export const PriceMap$inboundSchema: z.ZodType<PriceMap> = z.record(
+  z.string(),
+  Money$inboundSchema,
+);

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

@@ -0,0 +1,23 @@
+/*
+ * Product group model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type ProductGroup = {
+  resource?: string;
+  id?: number;
+  name?: string;
+  links?: HalLinks;
+  [key: string]: unknown;
+};
+
+/** @internal */
+export const ProductGroup$inboundSchema: z.ZodType<ProductGroup> = z.object({
+  resource: z.string().optional(),
+  id: z.number().optional(),
+  name: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((v) => remap$(v, { _links: "links" }) as ProductGroup);

package/src/models/commerce/product-offer.ts

@@ -0,0 +1,31 @@
+/*
+ * Product offer model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { PriceMap, PriceMap$inboundSchema } from "./money.js";
+
+export type ProductOffer = {
+  resource: string;
+  id: number;
+  productId: number;
+  type: string;
+  intervalId?: number | null;
+  quantity: number;
+  prices: PriceMap;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const ProductOffer$inboundSchema: z.ZodType<ProductOffer> = z.object({
+  resource: z.string(),
+  id: z.number(),
+  productId: z.number(),
+  type: z.string(),
+  intervalId: z.number().nullable().optional(),
+  quantity: z.number(),
+  prices: PriceMap$inboundSchema,
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => remap$(v, { _links: "links" }) as ProductOffer);

package/src/models/commerce/product.ts

@@ -0,0 +1,153 @@
+/*
+ * Commerce product models.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Paginated, buildPaginated } from "../pagination.js";
+import { Category, Category$inboundSchema } from "./category.js";
+import { ProductGroup, ProductGroup$inboundSchema } from "./product-group.js";
+import { ProductOffer, ProductOffer$inboundSchema } from "./product-offer.js";
+import { Route, Route$inboundSchema } from "./route.js";
+
+export type ReviewSummary = {
+  total: number;
+  rating: number | null;
+  breakdown: unknown[];
+};
+
+export type MeasurementValue = {
+  value: number;
+  unit: string;
+};
+
+export type Measurements = {
+  height?: MeasurementValue;
+  width?: MeasurementValue;
+  depth?: MeasurementValue;
+  weight?: MeasurementValue;
+};
+
+export type Product = {
+  resource: string;
+  id: number;
+  sku: string;
+  ean?: string | null;
+  mpn?: string | null;
+  asin?: string | null;
+  title: string;
+  shortTitle?: string | null;
+  coverImage?: string | null;
+  additionalImages?: string[];
+  shortDescription?: string | null;
+  description?: string | null;
+  bulletpoints?: string[];
+  boxContent?: string | null;
+  type?: string;
+  condition?: string;
+  categoryId?: number | null;
+  stock?: number | null;
+  isBackorderAllowed?: boolean;
+  routes?: Record<string, Route>;
+  offers?: ProductOffer[];
+  reviews?: ReviewSummary;
+  searches?: string[];
+  customFields?: unknown[];
+  publishedAt?: string | null;
+  videos?: unknown[];
+  updatedAt?: string;
+  createdAt?: string;
+  measurements?: Measurements;
+  category?: Category;
+  productGroups?: ProductGroup[];
+  links?: HalLinks;
+};
+
+export type ProductsListResponse = Paginated<Product>;
+
+const MeasurementValue$inboundSchema = z.object({
+  value: z.number(),
+  unit: z.string(),
+});
+
+const Measurements$inboundSchema = z.object({
+  height: MeasurementValue$inboundSchema.optional(),
+  width: MeasurementValue$inboundSchema.optional(),
+  depth: MeasurementValue$inboundSchema.optional(),
+  weight: MeasurementValue$inboundSchema.optional(),
+});
+
+const ReviewSummary$inboundSchema = z.object({
+  total: z.number(),
+  rating: z.number().nullable(),
+  breakdown: z.array(z.any()),
+});
+
+const ProductEmbedded$inboundSchema = z.object({
+  category: Category$inboundSchema.optional(),
+  product_groups: z.array(ProductGroup$inboundSchema).optional(),
+}).loose();
+
+/** @internal */
+export const Product$inboundSchema: z.ZodType<Product> = z.object({
+  resource: z.string(),
+  id: z.number(),
+  sku: z.string(),
+  ean: z.string().nullable().optional(),
+  mpn: z.string().nullable().optional(),
+  asin: z.string().nullable().optional(),
+  title: z.string(),
+  shortTitle: z.string().nullable().optional(),
+  coverImage: z.string().nullable().optional(),
+  additionalImages: z.array(z.string()).optional(),
+  shortDescription: z.string().nullable().optional(),
+  description: z.string().nullable().optional(),
+  bulletpoints: z.array(z.string()).optional(),
+  boxContent: z.string().nullable().optional(),
+  type: z.string().optional(),
+  condition: z.string().optional(),
+  categoryId: z.number().nullable().optional(),
+  stock: z.number().nullable().optional(),
+  isBackorderAllowed: z.boolean().optional(),
+  routes: z.record(z.string(), Route$inboundSchema).optional(),
+  offers: z.array(ProductOffer$inboundSchema).optional(),
+  reviews: ReviewSummary$inboundSchema.optional(),
+  searches: z.array(z.string()).optional(),
+  customFields: z.array(z.any()).optional(),
+  publishedAt: z.string().nullable().optional(),
+  videos: z.array(z.any()).optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  measurements: Measurements$inboundSchema.optional(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: ProductEmbedded$inboundSchema.optional(),
+}).transform((v) => {
+  const { _embedded } = v;
+  const category = _embedded?.category;
+  const productGroups = _embedded?.product_groups;
+
+  const remapped = remap$(v, { _links: "links", _embedded: null });
+
+  if (category !== undefined) {
+    (remapped as Product).category = category;
+  }
+  if (productGroups !== undefined) {
+    (remapped as Product).productGroups = productGroups;
+  }
+
+  return remapped as Product;
+});
+
+/** @internal */
+export const ProductsListResponse$inboundSchema: z.ZodType<
+  ProductsListResponse
+> = z.object({
+  _embedded: z.object({
+    products: z.array(Product$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(v._embedded.products, v.count, v._links)
+);

package/src/models/commerce/route.ts

@@ -0,0 +1,29 @@
+/*
+ * Route model.
+ */
+
+import * as z from "zod/v4";
+
+export type RouteParameters = Record<string, string | number>;
+
+export type Route = {
+  resource: string;
+  name: string;
+  locale: string;
+  parameters: RouteParameters;
+};
+
+/** @internal */
+export const RouteParameters$inboundSchema: z.ZodType<RouteParameters> = z
+  .record(
+    z.string(),
+    z.union([z.string(), z.number()]),
+  );
+
+/** @internal */
+export const Route$inboundSchema: z.ZodType<Route> = z.object({
+  resource: z.string(),
+  name: z.string(),
+  locale: z.string(),
+  parameters: RouteParameters$inboundSchema,
+});

package/src/models/common/amount.ts

@@ -0,0 +1,16 @@
+/*
+ * Currency amount model (string value + currency code).
+ */
+
+import * as z from "zod/v4";
+
+export type CurrencyAmount = {
+  value: string;
+  currency: string;
+};
+
+/** @internal */
+export const CurrencyAmount$inboundSchema: z.ZodType<CurrencyAmount> = z.object({
+  value: z.string(),
+  currency: z.string(),
+});

package/src/models/common/index.ts

@@ -0,0 +1,6 @@
+/*
+ * Common/shared models.
+ */
+
+export * from "./tag.js";
+export * from "./amount.js";

package/src/models/common/tag.ts

@@ -0,0 +1,28 @@
+/*
+ * Tag model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type Tag = {
+  resource: string;
+  id: number;
+  label: string;
+  color: string;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const Tag$inboundSchema: z.ZodType<Tag> = z.object({
+  resource: z.string(),
+  id: z.number(),
+  label: z.string(),
+  color: z.string(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => remap$(v, { _links: "links" }) as Tag);

package/src/models/hal.ts

@@ -0,0 +1,24 @@
+/*
+ * Shared HAL link types.
+ */
+
+import * as z from "zod/v4";
+
+export type HalLink = {
+  href: string;
+  type?: string | null | undefined;
+};
+
+export type HalLinks = Record<string, HalLink | null | undefined>;
+
+/** @internal */
+export const HalLink$inboundSchema: z.ZodType<HalLink> = z.object({
+  href: z.string(),
+  type: z.string().nullable().optional(),
+});
+
+/** @internal */
+export const HalLinks$inboundSchema: z.ZodType<HalLinks> = z.record(
+  z.string(),
+  z.union([HalLink$inboundSchema, z.null()]),
+);

package/src/models/index.ts

@@ -1 +1,5 @@
 export * from "./security.js";
+export * from "./common/index.js";
+export * from "./commerce/index.js";
+export * from "./hal.js";
+export * from "./pagination.js";