@ominity/api-typescript 0.0.3 → 1.0.0

package/src/models/commerce/order.ts

@@ -0,0 +1,85 @@
+/*
+ * Commerce Order model.
+ */
+
+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";
+import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.js";
+
+export type ShippingTotals = {
+    shippingAmount: CurrencyAmount;
+    discountAmount: CurrencyAmount;
+    vatAmount: CurrencyAmount;
+    totalAmount: CurrencyAmount;
+};
+
+export type Order = {
+    resource: string;
+    id: number;
+    customerId: number;
+    cartId: string | null;
+    channelId: number;
+    languageId: number | null;
+    number: string;
+    invoiceId: number | null;
+    status: string;
+    companyName: string;
+    companyVat: string;
+    billingAddress: Address;
+    shippingAddress: Address;
+    subtotalAmount: CurrencyAmount;
+    shipping: ShippingTotals;
+    discountAmount: CurrencyAmount;
+    vatAmount: CurrencyAmount;
+    totalAmount: CurrencyAmount;
+    promotionCodes: Array<string>;
+    shippingMethodId: number | null;
+    isTaxExempt: boolean;
+    notes: string;
+    updatedAt: string;
+    createdAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const ShippingTotals$inboundSchema: z.ZodType<ShippingTotals> = z.object({
+    shippingAmount: CurrencyAmount$inboundSchema,
+    discountAmount: CurrencyAmount$inboundSchema,
+    vatAmount: CurrencyAmount$inboundSchema,
+    totalAmount: CurrencyAmount$inboundSchema,
+});
+
+/** @internal */
+export const Order$inboundSchema: z.ZodType<Order> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    customerId: z.number(),
+    cartId: z.string().nullable(),
+    channelId: z.number(),
+    languageId: z.number().nullable(),
+    number: z.string(),
+    invoiceId: z.number().nullable(),
+    status: z.string(),
+    companyName: z.string(),
+    companyVat: z.string(),
+    billingAddress: Address$inboundSchema,
+    shippingAddress: Address$inboundSchema,
+    subtotalAmount: CurrencyAmount$inboundSchema,
+    shipping: ShippingTotals$inboundSchema,
+    discountAmount: CurrencyAmount$inboundSchema,
+    vatAmount: CurrencyAmount$inboundSchema,
+    totalAmount: CurrencyAmount$inboundSchema,
+    promotionCodes: z.array(z.string()),
+    shippingMethodId: z.number().nullable(),
+    isTaxExempt: z.boolean(),
+    notes: z.string(),
+    updatedAt: z.string(),
+    createdAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as Order;
+});

package/src/models/commerce/payment.ts

@@ -0,0 +1,47 @@
+/*
+ * Commerce Payment model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.js";
+
+export type Payment = {
+    resource: string;
+    id: number;
+    customerId: number;
+    paymentmethodId: number;
+    status: string;
+    type: string;
+    amount: CurrencyAmount;
+    description: string;
+    invoiceId: number | null;
+    expiresAt: string | null;
+    completedAt: string | null;
+    updatedAt: string;
+    createdAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const Payment$inboundSchema: z.ZodType<Payment> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    customerId: z.number(),
+    paymentmethodId: z.number(),
+    status: z.string(),
+    type: z.string(),
+    amount: CurrencyAmount$inboundSchema,
+    description: z.string(),
+    invoiceId: z.nullable(z.number()),
+    expiresAt: z.string().nullable(),
+    completedAt: z.string().nullable(),
+    updatedAt: z.string(),
+    createdAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as Payment;
+});

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

@@ -1,5 +1,5 @@
 /*
- * Product group model.
+ * Commerce Product Group model.
  */
 
 import * as z from "zod/v4";
@@ -7,17 +7,36 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
 
 export type ProductGroup = {
-  resource?: string;
-  id?: number;
-  name?: string;
+  resource: string;
+  id: number;
+  name: string;
+  slug: string;
+  description: string | null;
+  parentId: number | null;
+  metaTitle: string | null;
+  metaDescription: string | null;
+  metaKeywords: string | null;
+  createdAt: string;
+  updatedAt: 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(),
+  resource: z.string(),
+  id: z.number(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.nullable(z.string()),
+  parentId: z.nullable(z.number()),
+  metaTitle: z.nullable(z.string()),
+  metaDescription: z.nullable(z.string()),
+  metaKeywords: z.nullable(z.string()),
+  createdAt: z.string(),
+  updatedAt: z.string(),
   _links: HalLinks$inboundSchema.optional(),
-}).loose().transform((v) => remap$(v, { _links: "links" }) as ProductGroup);
+}).transform((v) => {
+  return remap$(v, {
+    "_links": "links",
+  }) as ProductGroup;
+});

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

@@ -1,5 +1,5 @@
 /*
- * Product offer model.
+ * Commerce Product Offer model.
  */
 
 import * as z from "zod/v4";
@@ -12,7 +12,7 @@ export type ProductOffer = {
   id: number;
   productId: number;
   type: string;
-  intervalId?: number | null;
+  intervalId: number | null;
   quantity: number;
   prices: PriceMap;
   links?: HalLinks;
@@ -24,8 +24,12 @@ export const ProductOffer$inboundSchema: z.ZodType<ProductOffer> = z.object({
   id: z.number(),
   productId: z.number(),
   type: z.string(),
-  intervalId: z.number().nullable().optional(),
+  intervalId: z.nullable(z.number()),
   quantity: z.number(),
   prices: PriceMap$inboundSchema,
   _links: HalLinks$inboundSchema.optional(),
-}).transform((v) => remap$(v, { _links: "links" }) as ProductOffer);
+}).transform((v) => {
+  return remap$(v, {
+    "_links": "links",
+  }) as ProductOffer;
+});

package/src/models/commerce/product.ts

@@ -1,153 +1,139 @@
 /*
- * Commerce product models.
+ * Commerce Product model.
  */
 
 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 ProductRoute = {
+  resource: string;
+  name: string;
+  locale: string;
+  parameters: Record<string, any>;
 };
 
-export type MeasurementValue = {
+export type ProductMeasurement = {
   value: number;
   unit: string;
 };
 
-export type Measurements = {
-  height?: MeasurementValue;
-  width?: MeasurementValue;
-  depth?: MeasurementValue;
-  weight?: MeasurementValue;
+export type ProductMeasurements = {
+  height?: ProductMeasurement;
+  width?: ProductMeasurement;
+  depth?: ProductMeasurement;
+  weight?: ProductMeasurement;
+};
+
+export type ProductReviewBreakdown = {
+  rating: number;
+  count: number;
+};
+
+export type ProductReviews = {
+  total: number;
+  rating: number | null;
+  breakdown: Array<ProductReviewBreakdown>;
 };
 
 export type Product = {
   resource: string;
   id: number;
   sku: string;
-  ean?: string | null;
-  mpn?: string | null;
-  asin?: string | null;
+  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[];
+  shortTitle: string | null;
+  coverImage: string | null;
+  additionalImages: Array<string>;
+  shortDescription: string | null;
+  description: string | null;
+  bulletpoints: Array<string>;
+  boxContent: string | null;
+  type: string;
+  condition: string;
+  categoryId: number;
+  stock: number;
+  isBackorderAllowed: boolean;
+  routes: Record<string, ProductRoute>;
+  measurements?: ProductMeasurements;
+  reviews?: ProductReviews;
+  searches: Array<string>;
+  customFields: Array<any>;
+  publishedAt: string | null;
+  updatedAt: string;
+  createdAt: string;
   links?: HalLinks;
 };
 
-export type ProductsListResponse = Paginated<Product>;
+/** @internal */
+export const ProductRoute$inboundSchema: z.ZodType<ProductRoute> = z.object({
+  resource: z.string(),
+  name: z.string(),
+  locale: z.string(),
+  parameters: z.record(z.string(), z.any()),
+});
 
-const MeasurementValue$inboundSchema = z.object({
+/** @internal */
+export const ProductMeasurement$inboundSchema: z.ZodType<ProductMeasurement> = 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(),
+/** @internal */
+export const ProductMeasurements$inboundSchema: z.ZodType<ProductMeasurements> = z.object({
+  height: ProductMeasurement$inboundSchema.optional(),
+  width: ProductMeasurement$inboundSchema.optional(),
+  depth: ProductMeasurement$inboundSchema.optional(),
+  weight: ProductMeasurement$inboundSchema.optional(),
+}) as unknown as z.ZodType<ProductMeasurements>;
+
+/** @internal */
+export const ProductReviewBreakdown$inboundSchema: z.ZodType<ProductReviewBreakdown> = z.object({
+  rating: z.number(),
+  count: z.number(),
 });
 
-const ReviewSummary$inboundSchema = z.object({
+/** @internal */
+export const ProductReviews$inboundSchema: z.ZodType<ProductReviews> = z.object({
   total: z.number(),
-  rating: z.number().nullable(),
-  breakdown: z.array(z.any()),
+  rating: z.nullable(z.number()),
+  breakdown: z.array(ProductReviewBreakdown$inboundSchema),
 });
 
-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(),
+  ean: z.nullable(z.string()),
+  mpn: z.nullable(z.string()),
+  asin: z.nullable(z.string()),
   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(),
+  shortTitle: z.nullable(z.string()),
+  coverImage: z.nullable(z.string()),
+  additionalImages: z.array(z.string()),
+  shortDescription: z.nullable(z.string()),
+  description: z.nullable(z.string()),
+  bulletpoints: z.array(z.string()),
+  boxContent: z.nullable(z.string()),
+  type: z.string(),
+  condition: z.string(),
+  categoryId: z.number(),
+  stock: z.number(),
+  isBackorderAllowed: z.boolean(),
+  routes: z.record(z.string(), ProductRoute$inboundSchema),
+  measurements: ProductMeasurements$inboundSchema.optional(),
+  reviews: ProductReviews$inboundSchema.optional(),
+  searches: z.array(z.string()),
+  customFields: z.array(z.any()),
+  publishedAt: z.nullable(z.string()),
+  updatedAt: z.string(),
+  createdAt: z.string(),
   _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;
+  return remap$(v, {
+    "_links": "links",
+  }) 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/review.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+
+
+// Placeholder - waiting for actual data structure from user
+export type Review = {
+    id?: string;
+    [key: string]: any;
+};
+
+/** @internal */
+export const Review$inboundSchema: z.ZodType<Review> = z
+    .object({
+        id: z.string().optional(),
+    })
+    .passthrough() as unknown as z.ZodType<Review>;
+
+/** @internal */
+export const Review$outboundSchema: z.ZodType<Review> = z
+    .object({
+        id: z.string().optional(),
+    })
+    .passthrough() as unknown as z.ZodType<Review>;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Review$ {
+    /** @deprecated use `Review$inboundSchema` instead. */
+    export const inboundSchema = Review$inboundSchema;
+    /** @deprecated use `Review$outboundSchema` instead. */
+    export const outboundSchema = Review$outboundSchema;
+}

package/src/models/commerce/shipping-method.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+
+
+// Placeholder - waiting for actual data structure from user
+export type ShippingMethod = {
+    id?: string;
+    name?: string;
+    [key: string]: any;
+};
+
+/** @internal */
+export const ShippingMethod$inboundSchema: z.ZodType<ShippingMethod> = z
+    .object({
+        id: z.string().optional(),
+        name: z.string().optional(),
+    })
+    .passthrough() as unknown as z.ZodType<ShippingMethod>;
+
+/** @internal */
+export const ShippingMethod$outboundSchema: z.ZodType<ShippingMethod> = z
+    .object({
+        id: z.string().optional(),
+        name: z.string().optional(),
+    })
+    .passthrough() as unknown as z.ZodType<ShippingMethod>;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ShippingMethod$ {
+    /** @deprecated use `ShippingMethod$inboundSchema` instead. */
+    export const inboundSchema = ShippingMethod$inboundSchema;
+    /** @deprecated use `ShippingMethod$outboundSchema` instead. */
+    export const outboundSchema = ShippingMethod$outboundSchema;
+}

package/src/models/commerce/shipping-zone.ts

@@ -0,0 +1,101 @@
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type ShippingZoneLinks = {
+    self: {
+        href: string;
+        type: string;
+    };
+};
+
+/** @internal */
+export const ShippingZoneLinks$inboundSchema: z.ZodType<ShippingZoneLinks> = z.object({
+    self: z.object({
+        href: z.string(),
+        type: z.string(),
+    }),
+});
+
+/** @internal */
+export const ShippingZoneLinks$outboundSchema: z.ZodType<ShippingZoneLinks> = z.object({
+    self: z.object({
+        href: z.string(),
+        type: z.string(),
+    }),
+});
+
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ShippingZoneLinks$ {
+    /** @deprecated use `ShippingZoneLinks$inboundSchema` instead. */
+    export const inboundSchema = ShippingZoneLinks$inboundSchema;
+    /** @deprecated use `ShippingZoneLinks$outboundSchema` instead. */
+    export const outboundSchema = ShippingZoneLinks$outboundSchema;
+}
+
+export type ShippingZone = {
+    resource: string;
+    id: string;
+    name: string;
+    regions?: Array<string> | null;
+    order?: number | null;
+    isActive: boolean;
+    isDefault: boolean;
+    updatedAt: string;
+    createdAt: string;
+    links: ShippingZoneLinks;
+};
+
+/** @internal */
+export const ShippingZone$inboundSchema: z.ZodType<ShippingZone> = z
+    .object({
+        resource: z.string(),
+        id: z.string(),
+        name: z.string(),
+        regions: z.array(z.string()).optional().nullable(),
+        order: z.number().int().optional().nullable(),
+        isActive: z.boolean(),
+        isDefault: z.boolean(),
+        updatedAt: z.string(),
+        createdAt: z.string(),
+        _links: ShippingZoneLinks$inboundSchema,
+    })
+    .transform((v) => {
+        return remap$(v, {
+            _links: "links",
+        });
+    }) as unknown as z.ZodType<ShippingZone>;
+
+/** @internal */
+export const ShippingZone$outboundSchema: z.ZodType<ShippingZone> = z
+    .object({
+        resource: z.string(),
+        id: z.string(),
+        name: z.string(),
+        regions: z.array(z.string()).optional().nullable(),
+        order: z.number().int().optional().nullable(),
+        isActive: z.boolean(),
+        isDefault: z.boolean(),
+        updatedAt: z.string(),
+        createdAt: z.string(),
+        links: ShippingZoneLinks$outboundSchema,
+    })
+    .transform((v) => {
+        return remap$(v, {
+            links: "_links",
+        });
+    }) as unknown as z.ZodType<ShippingZone>;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ShippingZone$ {
+    /** @deprecated use `ShippingZone$inboundSchema` instead. */
+    export const inboundSchema = ShippingZone$inboundSchema;
+    /** @deprecated use `ShippingZone$outboundSchema` instead. */
+    export const outboundSchema = ShippingZone$outboundSchema;
+}

package/src/models/commerce/subscription-interval.ts

@@ -0,0 +1,40 @@
+/*
+ * Commerce Subscription Interval model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type SubscriptionInterval = {
+    resource: string;
+    id: number;
+    name: string;
+    frequency: number;
+    intervalUnit: string;
+    daysOfWeek: Array<string>;
+    daysOfMonth: Array<number>;
+    months: Array<string>;
+    updatedAt: string;
+    createdAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const SubscriptionInterval$inboundSchema: z.ZodType<SubscriptionInterval> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    name: z.string(),
+    frequency: z.number(),
+    intervalUnit: z.string(),
+    daysOfWeek: z.array(z.string()),
+    daysOfMonth: z.array(z.number()),
+    months: z.array(z.string()),
+    updatedAt: z.string(),
+    createdAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as SubscriptionInterval;
+});