@ikas/storefront-api 4.0.0-alpha.78 → 4.0.0-alpha.8

package/src/__api/models/OrderLineOptionValue.ts

@@ -0,0 +1,18 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderLineOptionValueData {
+  name: string | null;
+  price: number | null;
+  value: string;
+
+  constructor(data: Partial<OrderLineOptionValueData> = {}) {
+    this.name = data.name || null;
+    this.price =
+      data.price !== undefined && data.price !== null ? data.price : null;
+    this.value = data.value || "";
+  }
+}
+
+export class OrderLineOptionValue extends OrderLineOptionValueData {}
+export type PartialOrderLineOptionValue = Partial<OrderLineOptionValue>;
+export type ReadOnlyOrderLineOptionValue = DeepReadonly<OrderLineOptionValue>;

package/src/__api/models/OrderLineVariant.ts

@@ -0,0 +1,56 @@
+import { DeepReadonly } from "ts-essentials";
+import { OrderLineVariantBrandData } from "./OrderLineVariantBrand";
+import { OrderLineVariantCategoryData } from "./OrderLineVariantCategory";
+import { OrderLineVariantPriceData } from "./OrderLineVariantPrice";
+import { OrderLineVariantVariantValuesData } from "./OrderLineVariantVariantValues";
+
+export class OrderLineVariantData {
+  barcodeList: string[] | null;
+  brand: OrderLineVariantBrandData | null;
+  categories: OrderLineVariantCategoryData[] | null;
+  id: string | null;
+  mainImageId: string | null;
+  name: string;
+  prices: OrderLineVariantPriceData[] | null;
+  productId: string | null;
+  sku: string | null;
+  slug: string | null;
+  tagIds: string[] | null;
+  taxValue: number | null;
+  type: number | null;
+  variantValues: OrderLineVariantVariantValuesData[] | null;
+  weight: number | null;
+
+  constructor(data: Partial<OrderLineVariantData> = {}) {
+    this.barcodeList = data.barcodeList || null;
+    this.brand = data.brand ? new OrderLineVariantBrandData(data.brand) : null;
+    this.categories = data.categories
+      ? data.categories.map((o) => new OrderLineVariantCategoryData(o))
+      : null;
+    this.id = data.id || null;
+    this.mainImageId = data.mainImageId || null;
+    this.name = data.name || "";
+    this.prices = data.prices
+      ? data.prices.map((o) => new OrderLineVariantPriceData(o))
+      : null;
+    this.productId = data.productId || null;
+    this.sku = data.sku || null;
+    this.slug = data.slug || null;
+    this.tagIds = data.tagIds || null;
+    this.taxValue =
+      data.taxValue !== undefined && data.taxValue !== null
+        ? data.taxValue
+        : null;
+    this.type =
+      data.type !== undefined && data.type !== null ? data.type : null;
+    this.variantValues = data.variantValues
+      ? data.variantValues.map((o) => new OrderLineVariantVariantValuesData(o))
+      : null;
+    this.weight =
+      data.weight !== undefined && data.weight !== null ? data.weight : null;
+  }
+}
+
+export class OrderLineVariant extends OrderLineVariantData {}
+export type PartialOrderLineVariant = Partial<OrderLineVariant>;
+export type ReadOnlyOrderLineVariant = DeepReadonly<OrderLineVariant>;

package/src/__api/models/OrderLineVariantBrand.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderLineVariantBrandData {
+  id: string;
+  name: string;
+
+  constructor(data: Partial<OrderLineVariantBrandData> = {}) {
+    this.id = data.id || "";
+    this.name = data.name || "";
+  }
+}
+
+export class OrderLineVariantBrand extends OrderLineVariantBrandData {}
+export type PartialOrderLineVariantBrand = Partial<OrderLineVariantBrand>;
+export type ReadOnlyOrderLineVariantBrand = DeepReadonly<OrderLineVariantBrand>;

package/src/__api/models/OrderLineVariantCategory.ts

@@ -0,0 +1,21 @@
+import { DeepReadonly } from "ts-essentials";
+import { OrderLineVariantCategoryPathData } from "./OrderLineVariantCategoryPath";
+
+export class OrderLineVariantCategoryData {
+  categoryPath: OrderLineVariantCategoryPathData[] | null;
+  id: string;
+  name: string;
+
+  constructor(data: Partial<OrderLineVariantCategoryData> = {}) {
+    this.categoryPath = data.categoryPath
+      ? data.categoryPath.map((o) => new OrderLineVariantCategoryPathData(o))
+      : null;
+    this.id = data.id || "";
+    this.name = data.name || "";
+  }
+}
+
+export class OrderLineVariantCategory extends OrderLineVariantCategoryData {}
+export type PartialOrderLineVariantCategory = Partial<OrderLineVariantCategory>;
+export type ReadOnlyOrderLineVariantCategory =
+  DeepReadonly<OrderLineVariantCategory>;

package/src/__api/models/OrderLineVariantCategoryPath.ts

@@ -0,0 +1,17 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderLineVariantCategoryPathData {
+  id: string;
+  name: string;
+
+  constructor(data: Partial<OrderLineVariantCategoryPathData> = {}) {
+    this.id = data.id || "";
+    this.name = data.name || "";
+  }
+}
+
+export class OrderLineVariantCategoryPath extends OrderLineVariantCategoryPathData {}
+export type PartialOrderLineVariantCategoryPath =
+  Partial<OrderLineVariantCategoryPath>;
+export type ReadOnlyOrderLineVariantCategoryPath =
+  DeepReadonly<OrderLineVariantCategoryPath>;

package/src/__api/models/OrderLineVariantPrice.ts

@@ -0,0 +1,27 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderLineVariantPriceData {
+  buyPrice: number | null;
+  currency: string | null;
+  discountPrice: number | null;
+  priceListId: string | null;
+  sellPrice: number;
+
+  constructor(data: Partial<OrderLineVariantPriceData> = {}) {
+    this.buyPrice =
+      data.buyPrice !== undefined && data.buyPrice !== null
+        ? data.buyPrice
+        : null;
+    this.currency = data.currency || null;
+    this.discountPrice =
+      data.discountPrice !== undefined && data.discountPrice !== null
+        ? data.discountPrice
+        : null;
+    this.priceListId = data.priceListId || null;
+    this.sellPrice = data.sellPrice || 0;
+  }
+}
+
+export class OrderLineVariantPrice extends OrderLineVariantPriceData {}
+export type PartialOrderLineVariantPrice = Partial<OrderLineVariantPrice>;
+export type ReadOnlyOrderLineVariantPrice = DeepReadonly<OrderLineVariantPrice>;

package/src/__api/models/OrderLineVariantVariantValues.ts

@@ -0,0 +1,23 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderLineVariantVariantValuesData {
+  order: number;
+  variantTypeId: string;
+  variantTypeName: string | null;
+  variantValueId: string;
+  variantValueName: string | null;
+
+  constructor(data: Partial<OrderLineVariantVariantValuesData> = {}) {
+    this.order = data.order || 0;
+    this.variantTypeId = data.variantTypeId || "";
+    this.variantTypeName = data.variantTypeName || null;
+    this.variantValueId = data.variantValueId || "";
+    this.variantValueName = data.variantValueName || null;
+  }
+}
+
+export class OrderLineVariantVariantValues extends OrderLineVariantVariantValuesData {}
+export type PartialOrderLineVariantVariantValues =
+  Partial<OrderLineVariantVariantValues>;
+export type ReadOnlyOrderLineVariantVariantValues =
+  DeepReadonly<OrderLineVariantVariantValues>;

package/src/__api/models/OrderPackage.ts

@@ -0,0 +1,33 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { OrderPackageFulfillStatusEnum } from "../types";
+import { TrackingInfoData } from "./TrackingInfo";
+
+export class OrderPackageData extends BaseModelData {
+  errorMessage: string | null;
+  note: string | null;
+  orderLineItemIds: string[];
+  orderPackageFulfillStatus: OrderPackageFulfillStatusEnum;
+  orderPackageNumber: string;
+  stockLocationId: string;
+  trackingInfo: TrackingInfoData | null;
+
+  constructor(data: Partial<OrderPackageData> = {}) {
+    super(data);
+
+    this.errorMessage = data.errorMessage || null;
+    this.note = data.note || null;
+    this.orderLineItemIds = data.orderLineItemIds || [];
+    this.orderPackageFulfillStatus =
+      data.orderPackageFulfillStatus || OrderPackageFulfillStatusEnum.CANCELLED;
+    this.orderPackageNumber = data.orderPackageNumber || "";
+    this.stockLocationId = data.stockLocationId || "";
+    this.trackingInfo = data.trackingInfo
+      ? new TrackingInfoData(data.trackingInfo)
+      : null;
+  }
+}
+
+export class OrderPackage extends OrderPackageData {}
+export type PartialOrderPackage = Partial<OrderPackage>;
+export type ReadOnlyOrderPackage = DeepReadonly<OrderPackage>;

package/src/__api/models/OrderPaymentMethod.ts

@@ -0,0 +1,22 @@
+import { DeepReadonly } from "ts-essentials";
+import { PaymentMethodTypeEnum } from "../types";
+
+export class OrderPaymentMethodData {
+  paymentGatewayCode: string | null;
+  paymentGatewayId: string | null;
+  paymentGatewayName: string | null;
+  price: number;
+  type: PaymentMethodTypeEnum;
+
+  constructor(data: Partial<OrderPaymentMethodData> = {}) {
+    this.paymentGatewayCode = data.paymentGatewayCode || null;
+    this.paymentGatewayId = data.paymentGatewayId || null;
+    this.paymentGatewayName = data.paymentGatewayName || null;
+    this.price = data.price || 0;
+    this.type = data.type || PaymentMethodTypeEnum.APP_PAYMENT;
+  }
+}
+
+export class OrderPaymentMethod extends OrderPaymentMethodData {}
+export type PartialOrderPaymentMethod = Partial<OrderPaymentMethod>;
+export type ReadOnlyOrderPaymentMethod = DeepReadonly<OrderPaymentMethod>;

package/src/__api/models/OrderRefundOrderLineInput.ts

@@ -0,0 +1,17 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderRefundOrderLineInputData {
+  orderLineItemId: string;
+  quantity: number;
+
+  constructor(data: Partial<OrderRefundOrderLineInputData> = {}) {
+    this.orderLineItemId = data.orderLineItemId || "";
+    this.quantity = data.quantity || 0;
+  }
+}
+
+export class OrderRefundOrderLineInput extends OrderRefundOrderLineInputData {}
+export type PartialOrderRefundOrderLineInput =
+  Partial<OrderRefundOrderLineInput>;
+export type ReadOnlyOrderRefundOrderLineInput =
+  DeepReadonly<OrderRefundOrderLineInput>;

package/src/__api/models/OrderRefundRequestInput.ts

@@ -0,0 +1,21 @@
+import { DeepReadonly } from "ts-essentials";
+import { OrderRefundOrderLineInputData } from "./OrderRefundOrderLineInput";
+
+export class OrderRefundRequestInputData {
+  orderId: string;
+  orderLineItems: OrderRefundOrderLineInputData[];
+  reason: string | null;
+
+  constructor(data: Partial<OrderRefundRequestInputData> = {}) {
+    this.orderId = data.orderId || "";
+    this.orderLineItems = data.orderLineItems
+      ? data.orderLineItems.map((o) => new OrderRefundOrderLineInputData(o))
+      : [];
+    this.reason = data.reason || null;
+  }
+}
+
+export class OrderRefundRequestInput extends OrderRefundRequestInputData {}
+export type PartialOrderRefundRequestInput = Partial<OrderRefundRequestInput>;
+export type ReadOnlyOrderRefundRequestInput =
+  DeepReadonly<OrderRefundRequestInput>;

package/src/__api/models/OrderRefundSettings.ts

@@ -0,0 +1,28 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+
+export class OrderRefundSettingsData extends BaseModelData {
+  autoApprove: boolean;
+  isActiveRefundSection: boolean;
+  orderRefundDayLimit: number | null;
+  refundDesc: string;
+  storefrontId: string | null;
+
+  constructor(data: Partial<OrderRefundSettingsData> = {}) {
+    super(data);
+
+    this.autoApprove = data.autoApprove || false;
+    this.isActiveRefundSection = data.isActiveRefundSection || false;
+    this.orderRefundDayLimit =
+      data.orderRefundDayLimit !== undefined &&
+      data.orderRefundDayLimit !== null
+        ? data.orderRefundDayLimit
+        : null;
+    this.refundDesc = data.refundDesc || "";
+    this.storefrontId = data.storefrontId || null;
+  }
+}
+
+export class OrderRefundSettings extends OrderRefundSettingsData {}
+export type PartialOrderRefundSettings = Partial<OrderRefundSettings>;
+export type ReadOnlyOrderRefundSettings = DeepReadonly<OrderRefundSettings>;

package/src/__api/models/OrderShippingLine.ts

@@ -0,0 +1,34 @@
+import { DeepReadonly } from "ts-essentials";
+import { PaymentMethodTypeEnum } from "../types";
+
+export class OrderShippingLineData {
+  finalPrice: number;
+  isRefunded: boolean | null;
+  paymentMethod: PaymentMethodTypeEnum | null;
+  price: number;
+  shippingSettingsId: string | null;
+  shippingZoneRateId: string | null;
+  taxValue: number | null;
+  title: string;
+
+  constructor(data: Partial<OrderShippingLineData> = {}) {
+    this.finalPrice = data.finalPrice || 0;
+    this.isRefunded =
+      data.isRefunded !== undefined && data.isRefunded !== null
+        ? data.isRefunded
+        : null;
+    this.paymentMethod = data.paymentMethod || null;
+    this.price = data.price || 0;
+    this.shippingSettingsId = data.shippingSettingsId || null;
+    this.shippingZoneRateId = data.shippingZoneRateId || null;
+    this.taxValue =
+      data.taxValue !== undefined && data.taxValue !== null
+        ? data.taxValue
+        : null;
+    this.title = data.title || "";
+  }
+}
+
+export class OrderShippingLine extends OrderShippingLineData {}
+export type PartialOrderShippingLine = Partial<OrderShippingLine>;
+export type ReadOnlyOrderShippingLine = DeepReadonly<OrderShippingLine>;

package/src/__api/models/OrderStorefrontRouting.ts

@@ -0,0 +1,29 @@
+import { DeepReadonly } from "ts-essentials";
+import { OrderStorefrontRoutingDynamicCurrencySettingsData } from "./OrderStorefrontRoutingDynamicCurrencySettings";
+
+export class OrderStorefrontRoutingData {
+  domain: string | null;
+  dynamicCurrencySettings: OrderStorefrontRoutingDynamicCurrencySettingsData | null;
+  id: string;
+  locale: string | null;
+  path: string | null;
+  priceListId: string | null;
+
+  constructor(data: Partial<OrderStorefrontRoutingData> = {}) {
+    this.domain = data.domain || null;
+    this.dynamicCurrencySettings = data.dynamicCurrencySettings
+      ? new OrderStorefrontRoutingDynamicCurrencySettingsData(
+          data.dynamicCurrencySettings
+        )
+      : null;
+    this.id = data.id || "";
+    this.locale = data.locale || null;
+    this.path = data.path || null;
+    this.priceListId = data.priceListId || null;
+  }
+}
+
+export class OrderStorefrontRouting extends OrderStorefrontRoutingData {}
+export type PartialOrderStorefrontRouting = Partial<OrderStorefrontRouting>;
+export type ReadOnlyOrderStorefrontRouting =
+  DeepReadonly<OrderStorefrontRouting>;

package/src/__api/models/OrderStorefrontRoutingDynamicCurrencySettings.ts

@@ -0,0 +1,19 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderStorefrontRoutingDynamicCurrencySettingsData {
+  roundingFormat: string | null;
+  targetCurrencyCode: string;
+
+  constructor(
+    data: Partial<OrderStorefrontRoutingDynamicCurrencySettingsData> = {}
+  ) {
+    this.roundingFormat = data.roundingFormat || null;
+    this.targetCurrencyCode = data.targetCurrencyCode || "";
+  }
+}
+
+export class OrderStorefrontRoutingDynamicCurrencySettings extends OrderStorefrontRoutingDynamicCurrencySettingsData {}
+export type PartialOrderStorefrontRoutingDynamicCurrencySettings =
+  Partial<OrderStorefrontRoutingDynamicCurrencySettings>;
+export type ReadOnlyOrderStorefrontRoutingDynamicCurrencySettings =
+  DeepReadonly<OrderStorefrontRoutingDynamicCurrencySettings>;

package/src/__api/models/OrderTaxLine.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class OrderTaxLineData {
+  price: number;
+  rate: number;
+
+  constructor(data: Partial<OrderTaxLineData> = {}) {
+    this.price = data.price || 0;
+    this.rate = data.rate || 0;
+  }
+}
+
+export class OrderTaxLine extends OrderTaxLineData {}
+export type PartialOrderTaxLine = Partial<OrderTaxLine>;
+export type ReadOnlyOrderTaxLine = DeepReadonly<OrderTaxLine>;

package/src/__api/models/PaginationInput.ts

@@ -0,0 +1,17 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class PaginationInputData {
+  limit: number | null;
+  page: number | null;
+
+  constructor(data: Partial<PaginationInputData> = {}) {
+    this.limit =
+      data.limit !== undefined && data.limit !== null ? data.limit : null;
+    this.page =
+      data.page !== undefined && data.page !== null ? data.page : null;
+  }
+}
+
+export class PaginationInput extends PaginationInputData {}
+export type PartialPaginationInput = Partial<PaginationInput>;
+export type ReadOnlyPaginationInput = DeepReadonly<PaginationInput>;

package/src/__api/models/PaymentGateway.ts

@@ -0,0 +1,61 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { PaymentMethodEnum, PaymentGatewayTypeEnum } from "../types";
+import { AdditionalPriceData } from "./AdditionalPrice";
+import { PaymentGatewayPaymentMethodData } from "./PaymentGatewayPaymentMethod";
+import { PaymentGatewaySettingsData } from "./PaymentGatewaySettings";
+import { PaymentGatewayTranslationData } from "./PaymentGatewayTranslation";
+
+export class PaymentGatewayData extends BaseModelData {
+  additionalPrices: AdditionalPriceData[] | null;
+  availableCountries: string[] | null;
+  code: string;
+  description: string | null;
+  logoUrl: string | null;
+  masterPassClientId: string | null;
+  name: string;
+  paymentGatewayProviderId: string | null;
+  paymentMethodType: PaymentMethodEnum;
+  paymentMethods: PaymentGatewayPaymentMethodData[];
+  settings: PaymentGatewaySettingsData[] | null;
+  supportedCurrencies: string[] | null;
+  testMode: boolean | null;
+  translations: PaymentGatewayTranslationData[] | null;
+  type: PaymentGatewayTypeEnum;
+
+  constructor(data: Partial<PaymentGatewayData> = {}) {
+    super(data);
+
+    this.additionalPrices = data.additionalPrices
+      ? data.additionalPrices.map((a) => new AdditionalPriceData(a))
+      : null;
+    this.availableCountries = data.availableCountries || null;
+    this.code = data.code || "";
+    this.description = data.description || null;
+    this.logoUrl = data.logoUrl || null;
+    this.masterPassClientId = data.masterPassClientId || null;
+    this.name = data.name || "";
+    this.paymentGatewayProviderId = data.paymentGatewayProviderId || null;
+    this.paymentMethodType =
+      data.paymentMethodType || PaymentMethodEnum.APP_PAYMENT;
+    this.paymentMethods = data.paymentMethods
+      ? data.paymentMethods.map((p) => new PaymentGatewayPaymentMethodData(p))
+      : [];
+    this.settings = data.settings
+      ? data.settings.map((p) => new PaymentGatewaySettingsData(p))
+      : null;
+    this.supportedCurrencies = data.supportedCurrencies || null;
+    this.testMode =
+      data.testMode !== undefined && data.testMode !== null
+        ? data.testMode
+        : null;
+    this.translations = data.translations
+      ? data.translations.map((p) => new PaymentGatewayTranslationData(p))
+      : null;
+    this.type = data.type || PaymentGatewayTypeEnum.EXTERNAL;
+  }
+}
+
+export class PaymentGateway extends PaymentGatewayData {}
+export type PartialPaymentGateway = Partial<PaymentGateway>;
+export type ReadOnlyPaymentGateway = DeepReadonly<PaymentGateway>;

package/src/__api/models/PaymentGatewayPaymentMethod.ts

@@ -0,0 +1,17 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class PaymentGatewayPaymentMethodData {
+  logoUrl: string | null;
+  name: string;
+
+  constructor(data: Partial<PaymentGatewayPaymentMethodData> = {}) {
+    this.logoUrl = data.logoUrl || null;
+    this.name = data.name || "";
+  }
+}
+
+export class PaymentGatewayPaymentMethod extends PaymentGatewayPaymentMethodData {}
+export type PartialPaymentGatewayPaymentMethod =
+  Partial<PaymentGatewayPaymentMethod>;
+export type ReadOnlyPaymentGatewayPaymentMethod =
+  DeepReadonly<PaymentGatewayPaymentMethod>;

package/src/__api/models/PaymentGatewaySettings.ts

@@ -0,0 +1,21 @@
+import { DeepReadonly } from "ts-essentials";
+import { PaymentGatewaySettingsTypeEnum } from "../types";
+
+export class PaymentGatewaySettingsData {
+  label: string;
+  order: number;
+  type: PaymentGatewaySettingsTypeEnum;
+  value: string | null;
+
+  constructor(data: Partial<PaymentGatewaySettingsData> = {}) {
+    this.label = data.label || "";
+    this.order = data.order || 0;
+    this.type = data.type || PaymentGatewaySettingsTypeEnum.NUMBER;
+    this.value = data.value || null;
+  }
+}
+
+export class PaymentGatewaySettings extends PaymentGatewaySettingsData {}
+export type PartialPaymentGatewaySettings = Partial<PaymentGatewaySettings>;
+export type ReadOnlyPaymentGatewaySettings =
+  DeepReadonly<PaymentGatewaySettings>;

package/src/__api/models/PaymentGatewayTranslation.ts

@@ -0,0 +1,19 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class PaymentGatewayTranslationData {
+  description: string | null;
+  locale: string | null;
+  name: string | null;
+
+  constructor(data: Partial<PaymentGatewayTranslationData> = {}) {
+    this.description = data.description || null;
+    this.locale = data.locale || null;
+    this.name = data.name || null;
+  }
+}
+
+export class PaymentGatewayTranslation extends PaymentGatewayTranslationData {}
+export type PartialPaymentGatewayTranslation =
+  Partial<PaymentGatewayTranslation>;
+export type ReadOnlyPaymentGatewayTranslation =
+  DeepReadonly<PaymentGatewayTranslation>;

package/src/__api/models/PaymentMethodDetailInput.ts

@@ -0,0 +1,26 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class PaymentMethodDetailInputData {
+  cardHolderName: string;
+  cardNumber: string;
+  cvv: string;
+  expiredMonth: number;
+  expiredYear: number;
+  installmentCount: number;
+  threeDSecure: boolean;
+
+  constructor(data: Partial<PaymentMethodDetailInputData> = {}) {
+    this.cardHolderName = data.cardHolderName || "";
+    this.cardNumber = data.cardNumber || "";
+    this.cvv = data.cvv || "";
+    this.expiredMonth = data.expiredMonth || 0;
+    this.expiredYear = data.expiredYear || 0;
+    this.installmentCount = data.installmentCount || 0;
+    this.threeDSecure = data.threeDSecure || false;
+  }
+}
+
+export class PaymentMethodDetailInput extends PaymentMethodDetailInputData {}
+export type PartialPaymentMethodDetailInput = Partial<PaymentMethodDetailInput>;
+export type ReadOnlyPaymentMethodDetailInput =
+  DeepReadonly<PaymentMethodDetailInput>;

package/src/__api/models/Product.ts

@@ -0,0 +1,69 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { ProductTypeEnum } from "../types";
+import { ProductAttributeValueData } from "./ProductAttributeValue";
+import { HTMLMetaDataData } from "./HTMLMetaData";
+import { ProductVariantTypeData } from "./ProductVariantType";
+import { ProductTranslationData } from "./ProductTranslation";
+import { VariantData } from "./Variant";
+
+export class ProductData extends BaseModelData {
+  attributes: ProductAttributeValueData[] | null;
+  brandId: string | null;
+  categoryIds: string[] | null;
+  description: string | null;
+  groupVariantsByVariantTypeId: string | null;
+  maxQuantityPerCart: number | null;
+  metaData: HTMLMetaDataData | null;
+  name: string;
+  productOptionSetId: string | null;
+  productVariantTypes: ProductVariantTypeData[] | null;
+  salesChannelIds: string[] | null;
+  shortDescription: string | null;
+  tagIds: string[] | null;
+  translations: ProductTranslationData[] | null;
+  type: ProductTypeEnum;
+  variants: VariantData[];
+  vendorId: string | null;
+  weight: number | null;
+
+  constructor(data: Partial<ProductData> = {}) {
+    super(data);
+
+    this.attributes = data.attributes
+      ? data.attributes.map((p) => new ProductAttributeValueData(p))
+      : null;
+    this.brandId = data.brandId || null;
+    this.categoryIds = data.categoryIds || null;
+    this.description = data.description || null;
+    this.groupVariantsByVariantTypeId =
+      data.groupVariantsByVariantTypeId || null;
+    this.maxQuantityPerCart =
+      data.maxQuantityPerCart !== undefined && data.maxQuantityPerCart !== null
+        ? data.maxQuantityPerCart
+        : null;
+    this.metaData = data.metaData ? new HTMLMetaDataData(data.metaData) : null;
+    this.name = data.name || "";
+    this.productOptionSetId = data.productOptionSetId || null;
+    this.productVariantTypes = data.productVariantTypes
+      ? data.productVariantTypes.map((p) => new ProductVariantTypeData(p))
+      : null;
+    this.salesChannelIds = data.salesChannelIds || null;
+    this.shortDescription = data.shortDescription || null;
+    this.tagIds = data.tagIds || null;
+    this.translations = data.translations
+      ? data.translations.map((p) => new ProductTranslationData(p))
+      : null;
+    this.type = data.type || ProductTypeEnum.DIGITAL;
+    this.variants = data.variants
+      ? data.variants.map((v) => new VariantData(v))
+      : [];
+    this.vendorId = data.vendorId || null;
+    this.weight =
+      data.weight !== undefined && data.weight !== null ? data.weight : null;
+  }
+}
+
+export class Product extends ProductData {}
+export type PartialProduct = Partial<Product>;
+export type ReadOnlyProduct = DeepReadonly<Product>;