@ominity/api-typescript 0.0.1 → 0.0.3

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

package/src/models/operations/commerce-cart-items.ts

@@ -0,0 +1,125 @@
+/*
+ * Commerce cart items operations.
+ */
+
+import * as z from "zod/v4";
+import { CartItem, CartItemsListResponse } from "../commerce/cart-item.js";
+
+export type CartItemsListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type CartItemGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListCartItemsRequest = CartItemsListParams & {
+  cartId: string;
+};
+export type ListCartItemsResponse = CartItemsListResponse;
+
+export type GetCartItemRequest = CartItemGetParams & {
+  cartId: string;
+  itemId: string;
+};
+export type GetCartItemResponse = CartItem;
+
+export type CartItemCreateInput = {
+  productId: number;
+  productOfferId?: number | undefined;
+  quantity?: number | undefined;
+};
+export type CartItemUpdateInput = {
+  quantity?: number | undefined;
+};
+
+export type CreateCartItemRequest = {
+  cartId: string;
+  body: CartItemCreateInput;
+};
+export type CreateCartItemResponse = CartItem;
+
+export type UpdateCartItemRequest = {
+  cartId: string;
+  itemId: string;
+  body: CartItemUpdateInput;
+};
+export type UpdateCartItemResponse = CartItem;
+
+export type DeleteCartItemRequest = {
+  cartId: string;
+  itemId: string;
+};
+export type DeleteCartItemResponse = void;
+
+/** @internal */
+export const CartItemsListParams$outboundSchema: z.ZodType<CartItemsListParams> =
+  z.object({
+    page: z.number().int().optional(),
+    limit: z.number().int().optional(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+    filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+    sort: z.union([z.string(), z.array(z.string())]).optional(),
+  }).loose();
+
+/** @internal */
+export const CartItemGetParams$outboundSchema: z.ZodType<CartItemGetParams> = z
+  .object({
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const ListCartItemsRequest$outboundSchema: z.ZodType<
+  ListCartItemsRequest
+> = z.object({
+  cartId: z.string(),
+  page: z.number().int().optional(),
+  limit: z.number().int().optional(),
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+  filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+  sort: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+export const GetCartItemRequest$outboundSchema: z.ZodType<GetCartItemRequest> =
+  z.object({
+    cartId: z.string(),
+    itemId: z.string(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  }).loose();
+
+/** @internal */
+export const CreateCartItemRequest$outboundSchema: z.ZodType<
+  CreateCartItemRequest
+> = z.object({
+  cartId: z.string(),
+  body: z.object({
+    productId: z.number(),
+    productOfferId: z.number().optional(),
+    quantity: z.number().optional(),
+  }).loose(),
+});
+
+/** @internal */
+export const UpdateCartItemRequest$outboundSchema: z.ZodType<
+  UpdateCartItemRequest
+> = z.object({
+  cartId: z.string(),
+  itemId: z.string(),
+  body: z.object({
+    quantity: z.number().optional(),
+  }).loose(),
+});
+
+/** @internal */
+export const DeleteCartItemRequest$outboundSchema: z.ZodType<
+  DeleteCartItemRequest
+> = z.object({
+  cartId: z.string(),
+  itemId: z.string(),
+});

package/src/models/operations/commerce-carts.ts

@@ -0,0 +1,158 @@
+/*
+ * Commerce carts operations.
+ */
+
+import * as z from "zod/v4";
+import { Cart, CartType, CartsListResponse } from "../commerce/cart.js";
+import { Address, Address$inboundSchema } from "../commerce/address.js";
+
+export type CartsListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type CartGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListCartsRequest = CartsListParams;
+export type ListCartsResponse = CartsListResponse;
+
+export type GetCartRequest = CartGetParams & {
+  id: string;
+};
+
+export type GetCartResponse = Cart;
+
+export type CartItemInput = {
+  id?: string | undefined;
+  productId: number;
+  productOfferId?: number | undefined;
+  quantity?: number | undefined;
+};
+
+export type CartCreateInput = {
+  visitorId?: number | null | undefined;
+  customerId?: number | null | undefined;
+  userId?: number | null | undefined;
+  type?: CartType | undefined;
+  email?: string | null | undefined;
+  companyName?: string | null | undefined;
+  companyVat?: string | null | undefined;
+  taxExempt?: boolean | undefined;
+  country: string;
+  currency?: string | null | undefined;
+  billingAddress?: Address | null | undefined;
+  shippingAddress?: Address | null | undefined;
+  items?: CartItemInput[] | undefined;
+  shippingMethodId?: number | null | undefined;
+  promotionCodes?: string[] | null | undefined;
+};
+
+export type CartUpdateInput = {
+  visitorId?: number | null | undefined;
+  customerId?: number | null | undefined;
+  userId?: number | null | undefined;
+  email?: string | null | undefined;
+  companyName?: string | null | undefined;
+  companyVat?: string | null | undefined;
+  taxExempt?: boolean | undefined;
+  country?: string | undefined;
+  currency?: string | undefined;
+  billingAddress?: Address | null | undefined;
+  shippingAddress?: Address | null | undefined;
+  items?: CartItemInput[] | undefined;
+  shippingMethodId?: number | null | undefined;
+  promotionCodes?: string[] | null | undefined;
+};
+
+export type CreateCartRequest = CartCreateInput;
+export type CreateCartResponse = Cart;
+
+export type UpdateCartRequest = {
+  id: string;
+  body: CartUpdateInput;
+};
+
+export type UpdateCartResponse = Cart;
+
+/** @internal */
+export const CartsListParams$outboundSchema: z.ZodType<CartsListParams> = z
+  .object({
+    page: z.number().int().optional(),
+    limit: z.number().int().optional(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+    filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+    sort: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const CartGetParams$outboundSchema: z.ZodType<CartGetParams> = z.object({
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+export const GetCartRequest$outboundSchema: z.ZodType<GetCartRequest> = z.object({
+  id: z.string(),
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+const CartItemInput$outboundSchema: z.ZodType<CartItemInput> = z.object({
+  id: z.string().optional(),
+  productId: z.number(),
+  productOfferId: z.number().optional(),
+  quantity: z.number().optional(),
+}).loose();
+
+/** @internal */
+const CartType$outboundSchema: z.ZodType<CartType> = z.string().transform(
+  (value) => value as CartType,
+);
+
+export const CreateCartRequest$outboundSchema: z.ZodType<CreateCartRequest> = z
+  .object({
+    visitorId: z.number().nullable().optional(),
+    customerId: z.number().nullable().optional(),
+    userId: z.number().nullable().optional(),
+    type: CartType$outboundSchema.optional(),
+    email: z.string().nullable().optional(),
+    companyName: z.string().nullable().optional(),
+    companyVat: z.string().nullable().optional(),
+    taxExempt: z.boolean().optional(),
+    country: z.string(),
+    currency: z.string().nullable().optional(),
+    billingAddress: Address$inboundSchema.nullable().optional(),
+    shippingAddress: Address$inboundSchema.nullable().optional(),
+    items: z.array(CartItemInput$outboundSchema).optional(),
+    shippingMethodId: z.number().nullable().optional(),
+    promotionCodes: z.array(z.string()).nullable().optional(),
+  })
+  .loose()
+  .transform((v) => v as CreateCartRequest);
+
+/** @internal */
+export const UpdateCartRequest$outboundSchema: z.ZodType<UpdateCartRequest> = z
+  .object({
+    id: z.string(),
+    body: z.object({
+      visitorId: z.number().nullable().optional(),
+      customerId: z.number().nullable().optional(),
+      userId: z.number().nullable().optional(),
+      email: z.string().nullable().optional(),
+      companyName: z.string().nullable().optional(),
+      companyVat: z.string().nullable().optional(),
+      taxExempt: z.boolean().optional(),
+      country: z.string().optional(),
+      currency: z.string().optional(),
+      billingAddress: Address$inboundSchema.nullable().optional(),
+      shippingAddress: Address$inboundSchema.nullable().optional(),
+      items: z.array(CartItemInput$outboundSchema).optional(),
+      shippingMethodId: z.number().nullable().optional(),
+      promotionCodes: z.array(z.string()).nullable().optional(),
+    }).loose(),
+  }).transform((v) => v as UpdateCartRequest);

package/src/models/operations/commerce-categories.ts

@@ -0,0 +1,52 @@
+/*
+ * Commerce categories operations.
+ */
+
+import * as z from "zod/v4";
+import { Category, CategoriesListResponse } from "../commerce/category.js";
+
+export type CategoriesListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type CategoryGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListCategoriesRequest = CategoriesListParams;
+export type ListCategoriesResponse = CategoriesListResponse;
+
+export type GetCategoryRequest = CategoryGetParams & {
+  id: number | string;
+};
+
+export type GetCategoryResponse = Category;
+
+/** @internal */
+export const CategoriesListParams$outboundSchema: z.ZodType<
+  CategoriesListParams
+> = z.object({
+  page: z.number().int().optional(),
+  limit: z.number().int().optional(),
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+  filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+  sort: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+export const CategoryGetParams$outboundSchema: z.ZodType<CategoryGetParams> = z
+  .object({
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const GetCategoryRequest$outboundSchema: z.ZodType<GetCategoryRequest> =
+  z.object({
+    id: z.union([z.string(), z.number()]),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  }).loose();

package/src/models/operations/commerce-products.ts

@@ -0,0 +1,53 @@
+/*
+ * Commerce products operations.
+ */
+
+import * as z from "zod/v4";
+import { Product, ProductsListResponse } from "../commerce/product.js";
+
+export type ProductsListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type ProductGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListProductsRequest = ProductsListParams;
+export type ListProductsResponse = ProductsListResponse;
+
+export type GetProductRequest = ProductGetParams & {
+  id: number | string;
+};
+
+export type GetProductResponse = Product;
+
+/** @internal */
+export const ProductsListParams$outboundSchema: z.ZodType<ProductsListParams> = z
+  .object({
+    page: z.number().int().optional(),
+    limit: z.number().int().optional(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+    filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+    sort: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const ProductGetParams$outboundSchema: z.ZodType<ProductGetParams> = z
+  .object({
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const GetProductRequest$outboundSchema: z.ZodType<GetProductRequest> = z
+  .object({
+    id: z.union([z.string(), z.number()]),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();

package/src/models/operations/index.ts

@@ -1,2 +1,4 @@
-// Operation models will be defined as the SDK endpoints are implemented.
-export {};
+export * from "./commerce-products.js";
+export * from "./commerce-categories.js";
+export * from "./commerce-carts.js";
+export * from "./commerce-cart-items.js";